DatiCollezionati.java

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

  21. package org.openspcoop2.core.controllo_traffico.beans;

  23. import java.io.Serializable;
  24. import java.text.SimpleDateFormat;
  25. import java.util.ArrayList;
  26. import java.util.Date;
  27. import java.util.List;

  29. import org.openspcoop2.core.commons.CoreException;
  30. import org.openspcoop2.core.constants.TipoPdD;
  31. import org.openspcoop2.core.controllo_traffico.constants.TipoBanda;
  32. import org.openspcoop2.core.controllo_traffico.constants.TipoControlloPeriodo;
  33. import org.openspcoop2.core.controllo_traffico.constants.TipoFinestra;
  34. import org.openspcoop2.core.controllo_traffico.constants.TipoLatenza;
  35. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsa;
  36. import org.openspcoop2.core.controllo_traffico.driver.PolicyException;
  37. import org.openspcoop2.utils.Map;
  38. import org.openspcoop2.utils.MapKey;
  39. import org.openspcoop2.utils.date.DateManager;
  40. import org.openspcoop2.utils.date.DateUtils;
  41. import org.openspcoop2.utils.date.UnitaTemporale;
  42. import org.slf4j.Logger;

  44. /**
  45.  * DatiCollezionati 
  46.  *
  47.  * @author Andrea Poli (poli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. public class DatiCollezionati implements Serializable {

  53.     /**
  54.      * 
  55.      */
  56.     private static final long serialVersionUID = 1L;
  57.     
  58.     public DatiCollezionati(Date updatePolicyDate, Date gestorePolicyConfigDate) {
  59.         this.updatePolicyDate = updatePolicyDate;
  60.         this.gestorePolicyConfigDate = gestorePolicyConfigDate;
  61.     }

  63.     // data di lettura delle informazioni
  64.     private Date cloneDate = null; // non deve essere gestita. Viene solamente inizializzata ad ogni clone
  65.     
  66.     // tipo di risorsa
  67.     protected TipoRisorsa tipoRisorsa = null;
  68.     
  69.     // threads
  70.     protected Long activeRequestCounter = null; // tiene traccia del numero di richieste attive sempre. Utile in jmx
  71.     
  72.     // data di creazione
  73.     protected Date creationDate = null;
  74.     // data di registrazione/aggiornamento policy
  75.     private Date updatePolicyDate = null;
  76.     // dati impostazione gestore della policy
  77.     protected Date gestorePolicyConfigDate = null;
  78.     
  79.     // dati di attuazione manuale di un reset dei contatori
  80.     private Long manuallyResetPolicyTimeMillis = null;

  82.     private static final MapKey<String> START_PROCESS_REQUEST_TIME_MS = Map.newMapKey("START_PROCESS_REQUEST_TIME_MS");
  83.     
  84.     // dati iniziali
  85.     private UnitaTemporale policyDateTypeInterval = null;
  86.     private Integer policyDateInterval = null;
  87.     private Boolean policyDateCurrentInterval  = null;
  88.     private TipoFinestra policyDateWindowInterval = null;
  89.     protected Boolean policyRealtime  = null;
  90.     // dati dinamici
  91.     protected Date policyDate = null;
  92.     protected Long policyRequestCounter = null;
  93.     protected Long policyCounter = null; // utilizzato per tempi o banda
  94.     protected Long policyDenyRequestCounter = null;
  95.     private Date oldPolicyDate = null;
  96.     private Long oldPolicyRequestCounter = null;
  97.     private Long oldPolicyCounter = null; // utilizzato per tempi o banda
  98.     
  99.     // dati iniziali degrado prestazionale
  100.     private UnitaTemporale policyDegradoPrestazionaleDateTypeInterval = null;
  101.     private Integer policyDegradoPrestazionaleDateInterval  = null;
  102.     private Boolean policyDegradoPrestazionaleDateCurrentInterval = null;
  103.     private TipoFinestra policyDegradoPrestazionaleDateWindowInterval = null;
  104.     protected  Boolean policyDegradoPrestazionaleRealtime  = null;
  105.     // dati dinamici degrado prestazionale
  106.     protected Date policyDegradoPrestazionaleDate = null;
  107.     protected Long policyDegradoPrestazionaleRequestCounter = null;
  108.     protected Long policyDegradoPrestazionaleCounter= null;
  109.     private Date oldPolicyDegradoPrestazionaleDate = null;
  110.     private Long oldPolicyDegradoPrestazionaleRequestCounter = null;
  111.     private Long oldPolicyDegradoPrestazionaleCounter = null; // utilizzato per tempi o banda
  112.     
  113.         

  115.     public void initDatiIniziali(ActivePolicy activePolicy){
  116.         
  117.         // tipo di risorsa
  118.         this.tipoRisorsa = activePolicy.getTipoRisorsaPolicy();
  119.         
  120.         // threads
  121.         this.activeRequestCounter = 0l;
  122.         
  123.         // data di creazione
  124.         this.creationDate = DateManager.getDate();
  125.         // data di registrazione policy
  126.         this.updatePolicyDate = activePolicy.getInstanceConfiguration().getUpdateTime();
  127.         
  128.         // Policy
  129.         
  130.         if(!activePolicy.getConfigurazionePolicy().isSimultanee() 
  131.                 &&
  132.                 TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())){
  133.             
  134.             this.policyDateCurrentInterval = true; // cablato
  135.             
  136.             this.policyDateWindowInterval = activePolicy.getConfigurazionePolicy().getFinestraOsservazione();
  137.             
  138.             switch (activePolicy.getConfigurazionePolicy().getTipoIntervalloOsservazioneRealtime()) {
  139.             case SECONDI:
  140.                 this.policyDateTypeInterval = UnitaTemporale.SECONDI;
  141.                 break;
  142.             case MINUTI:
  143.                 this.policyDateTypeInterval = UnitaTemporale.MINUTI;
  144.                 break;
  145.             case ORARIO:
  146.                 this.policyDateTypeInterval = UnitaTemporale.ORARIO;
  147.                 break;
  148.             case GIORNALIERO:
  149.                 this.policyDateTypeInterval = UnitaTemporale.GIORNALIERO;
  150.                 break;
  151.             }
  152.             
  153.             this.policyDateInterval = activePolicy.getConfigurazionePolicy().getIntervalloOsservazione();
  154.             
  155.             this.policyRealtime = true;
  156.             
  157.         }
  158.         else if(TipoControlloPeriodo.STATISTIC.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())){
  159.             
  160.             this.policyDateWindowInterval = activePolicy.getConfigurazionePolicy().getFinestraOsservazione();
  161.             
  162.             if(TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  163.                 this.policyDateCurrentInterval = activePolicy.getConfigurazioneControlloTraffico().isElaborazioneStatistica_finestraScorrevole_gestioneIntervalloCorrente();
  164.                 this.policyDateTypeInterval = UnitaTemporale.ORARIO; // USARE SEMPRE L'INTERVALLO PIU' STRETTO. Se si introdurranno i minuti si dovrà utilizzare i minuti.
  165.                 
  166.                 // E' però necessaria la conversione in ore.
  167.                 switch (activePolicy.getConfigurazionePolicy().getTipoIntervalloOsservazioneStatistico()) {
  168.                 case ORARIO:
  169.                     this.policyDateInterval = activePolicy.getConfigurazionePolicy().getIntervalloOsservazione();
  170.                     break;
  171.                 case GIORNALIERO:
  172.                     this.policyDateInterval = activePolicy.getConfigurazionePolicy().getIntervalloOsservazione() * 24;
  173.                     break;
  174.                 case SETTIMANALE:
  175.                     this.policyDateInterval = activePolicy.getConfigurazionePolicy().getIntervalloOsservazione() * 24 * 7;
  176.                     break;
  177.                 case MENSILE:
  178.                     this.policyDateInterval = activePolicy.getConfigurazionePolicy().getIntervalloOsservazione() * 24 * 30; // (utilizzo 30 come giorni medi di un mese)
  179.                     break;
  180.                 }
  181.             }
  182.             else{
  183.                 this.policyDateCurrentInterval = true; // cablato
  184.                 
  185.                 switch (activePolicy.getConfigurazionePolicy().getTipoIntervalloOsservazioneStatistico()) {
  186.                 case ORARIO:
  187.                     this.policyDateTypeInterval = UnitaTemporale.ORARIO;
  188.                     break;
  189.                 case GIORNALIERO:
  190.                     this.policyDateTypeInterval = UnitaTemporale.GIORNALIERO;
  191.                     break;
  192.                 case SETTIMANALE:
  193.                     this.policyDateTypeInterval = UnitaTemporale.SETTIMANALE;
  194.                     break;
  195.                 case MENSILE:
  196.                     this.policyDateTypeInterval = UnitaTemporale.MENSILE;
  197.                     break;
  198.                 }
  199.                 
  200.                 this.policyDateInterval = activePolicy.getConfigurazionePolicy().getIntervalloOsservazione();
  201.             }
  202.             
  203.             this.policyRealtime = false;
  204.             
  205.         }
  206.         
  207.         
  208.         // DegradoPrestazionale
  209.         
  210.         if(activePolicy.getConfigurazionePolicy().isApplicabilitaDegradoPrestazionale()){
  211.         
  212.             if(TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeModalitaControllo())){
  213.                 
  214.                 this.policyDegradoPrestazionaleDateCurrentInterval = true; // cablato
  215.                 
  216.                 this.policyDegradoPrestazionaleDateWindowInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione();
  217.                 
  218.                 switch (activePolicy.getConfigurazionePolicy().getDegradoAvgTimeTipoIntervalloOsservazioneRealtime()) {
  219.                 case SECONDI:
  220.                     this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.SECONDI;
  221.                     break;
  222.                 case MINUTI:
  223.                     this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.MINUTI;
  224.                     break;
  225.                 case ORARIO:
  226.                     this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.ORARIO;
  227.                     break;
  228.                 case GIORNALIERO:
  229.                     this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.GIORNALIERO;
  230.                     break;
  231.                 }
  232.                 
  233.                 this.policyDegradoPrestazionaleDateInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeIntervalloOsservazione();
  234.                 
  235.                 this.policyDegradoPrestazionaleRealtime = true;
  236.                 
  237.             }
  238.             else if(TipoControlloPeriodo.STATISTIC.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeModalitaControllo())){
  239.                 
  240.                 this.policyDegradoPrestazionaleDateWindowInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione();
  241.                 
  242.                 if(TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione())){
  243.                     this.policyDegradoPrestazionaleDateCurrentInterval = activePolicy.getConfigurazioneControlloTraffico().isElaborazioneStatistica_finestraScorrevole_gestioneIntervalloCorrente();
  244.                     this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.ORARIO; // USARE SEMPRE L'INTERVALLO PIU' STRETTO. Se si introdurranno i minuti si dovrà utilizzare i minuti.
  245.                     
  246.                     // E' però necessaria la conversione in ore.
  247.                     switch (activePolicy.getConfigurazionePolicy().getDegradoAvgTimeTipoIntervalloOsservazioneStatistico()) {
  248.                     case ORARIO:
  249.                         this.policyDegradoPrestazionaleDateInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeIntervalloOsservazione();
  250.                         break;
  251.                     case GIORNALIERO:
  252.                         this.policyDegradoPrestazionaleDateInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeIntervalloOsservazione() * 24;
  253.                         break;
  254.                     case SETTIMANALE:
  255.                         this.policyDegradoPrestazionaleDateInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeIntervalloOsservazione() * 24 * 7;
  256.                         break;
  257.                     case MENSILE:
  258.                         this.policyDegradoPrestazionaleDateInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeIntervalloOsservazione() * 24 * 30; // (utilizzo 30 come giorni medi di un mese)
  259.                         break;
  260.                     }
  261.                 }
  262.                 else{
  263.                     this.policyDegradoPrestazionaleDateCurrentInterval = true; // cablato
  264.                     
  265.                     switch (activePolicy.getConfigurazionePolicy().getDegradoAvgTimeTipoIntervalloOsservazioneStatistico()) {
  266.                     case ORARIO:
  267.                         this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.ORARIO;
  268.                         break;
  269.                     case GIORNALIERO:
  270.                         this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.GIORNALIERO;
  271.                         break;
  272.                     case SETTIMANALE:
  273.                         this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.SETTIMANALE;
  274.                         break;
  275.                     case MENSILE:
  276.                         this.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.MENSILE;
  277.                         break;
  278.                     }
  279.                     
  280.                     this.policyDegradoPrestazionaleDateInterval = activePolicy.getConfigurazionePolicy().getDegradoAvgTimeIntervalloOsservazione();
  281.                 }
  282.                 
  283.                 this.policyDegradoPrestazionaleRealtime = false;
  284.                 
  285.             }
  286.             
  287.         }
  288.     }
  289.     
  290.     public DatiCollezionati newInstance() {
  291.         return internalNewInstance(false); // se servisse avere una immagine con i dati remoti, usare la clone con il boolean.
  292.     }
  293.     public DatiCollezionati newInstance(boolean readRemoteInfo) {
  294.         return internalNewInstance(readRemoteInfo); 
  295.     }
  296.     private DatiCollezionati internalNewInstance(boolean readRemoteInfo) {
  297.         Date updatePolicyDateCheck = new Date(this.updatePolicyDate.getTime());
  298.         Date gestorePolicyConfigDateCheck = null;
  299.         if(this.gestorePolicyConfigDate!=null) {
  300.             gestorePolicyConfigDateCheck = new Date(this.gestorePolicyConfigDate.getTime());
  301.         }
  302.         
  303.         DatiCollezionati dati = new DatiCollezionati(updatePolicyDateCheck, gestorePolicyConfigDateCheck);
  304.         
  305.         return setValuesIn(dati, readRemoteInfo);
  306.     }

  308.     public DatiCollezionati setValuesIn(DatiCollezionati dati, boolean readRemoteInfo){
  309.         
  310.         // data di registrazione/aggiornamento policy
  311.         
  312.         dati.cloneDate = DateManager.getDate();
  313.         
  314.         // tipo di risorsa
  315.         if(this.tipoRisorsa!=null){
  316.             dati.tipoRisorsa = TipoRisorsa.toEnumConstant(this.tipoRisorsa.getValue());
  317.         }
  318.         
  319.         // threads
  320.         Long getActiveRequestCounter = this.getActiveRequestCounter(readRemoteInfo);
  321.         if(getActiveRequestCounter!=null) {
  322.             dati.activeRequestCounter = Long.valueOf(getActiveRequestCounter.longValue()+"");
  323.         }
  324.         
  325.         // data di creazione
  326.         if(this.creationDate!=null) {
  327.             dati.creationDate = new Date(this.creationDate.getTime());
  328.         }
  329.         
  330.         // dati iniziali
  331.         if(this.policyDateTypeInterval!=null){
  332.             dati.policyDateTypeInterval = UnitaTemporale.toEnumConstant(this.policyDateTypeInterval.getValue());
  333.         }
  334.         if(this.policyDateInterval!=null){
  335.             dati.policyDateInterval = Integer.valueOf(this.policyDateInterval.intValue()+"");
  336.         }
  337.         if(this.policyDateCurrentInterval!=null){
  338.             dati.policyDateCurrentInterval = Boolean.valueOf(this.policyDateCurrentInterval.booleanValue()+"");
  339.         }
  340.         if(this.policyDateWindowInterval!=null){
  341.             dati.policyDateWindowInterval = TipoFinestra.toEnumConstant(this.policyDateWindowInterval.getValue());
  342.         }
  343.         if(this.policyRealtime!=null){
  344.             dati.policyRealtime = Boolean.valueOf(this.policyRealtime+"");
  345.         }
  346.         
  347.         // dati dinamici    
  348.         if(this.policyDate!=null){
  349.             dati.policyDate = new Date(this.policyDate.getTime());
  350.         }   
  351.         Long getPolicyRequestCounter = this.getPolicyRequestCounter(readRemoteInfo);
  352.         if(getPolicyRequestCounter!=null){
  353.             dati.policyRequestCounter = Long.valueOf(getPolicyRequestCounter.longValue()+"");
  354.         }
  355.         Long getPolicyCounter = this.getPolicyCounter(readRemoteInfo);
  356.         if(getPolicyCounter!=null){
  357.             dati.policyCounter = Long.valueOf(getPolicyCounter.longValue()+"");
  358.         }
  359.         Long getPolicyDenyRequestCounter = this.getPolicyDenyRequestCounter(readRemoteInfo);
  360.         if(getPolicyDenyRequestCounter!=null){
  361.             dati.policyDenyRequestCounter = Long.valueOf(getPolicyDenyRequestCounter.longValue()+"");
  362.         }
  363.         if(this.oldPolicyDate!=null){
  364.             dati.oldPolicyDate = new Date(this.oldPolicyDate.getTime());
  365.         }   
  366.         if(this.oldPolicyRequestCounter!=null){
  367.             dati.oldPolicyRequestCounter = Long.valueOf(this.oldPolicyRequestCounter.longValue()+"");
  368.         }
  369.         if(this.oldPolicyCounter!=null){
  370.             dati.oldPolicyCounter = Long.valueOf(this.oldPolicyCounter.longValue()+"");
  371.         }
  372.         
  373.         // dati iniziali degrado prestazionale
  374.         if(this.policyDegradoPrestazionaleDateTypeInterval!=null){
  375.             dati.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.toEnumConstant(this.policyDegradoPrestazionaleDateTypeInterval.getValue());
  376.         }
  377.         if(this.policyDegradoPrestazionaleDateInterval!=null){
  378.             dati.policyDegradoPrestazionaleDateInterval = Integer.valueOf(this.policyDegradoPrestazionaleDateInterval.intValue()+"");
  379.         }
  380.         if(this.policyDegradoPrestazionaleDateCurrentInterval!=null){
  381.             dati.policyDegradoPrestazionaleDateCurrentInterval = Boolean.valueOf(this.policyDegradoPrestazionaleDateCurrentInterval.booleanValue()+"");
  382.         }
  383.         if(this.policyDegradoPrestazionaleDateWindowInterval!=null){
  384.             dati.policyDegradoPrestazionaleDateWindowInterval = TipoFinestra.toEnumConstant(this.policyDegradoPrestazionaleDateWindowInterval.getValue());
  385.         }
  386.         if(this.policyDegradoPrestazionaleRealtime!=null){
  387.             dati.policyDegradoPrestazionaleRealtime = Boolean.valueOf(this.policyDegradoPrestazionaleRealtime.booleanValue()+"");
  388.         }
  389.         
  390.         // dati dinamici degrado prestazionale
  391.         if(this.policyDegradoPrestazionaleDate!=null){
  392.             dati.policyDegradoPrestazionaleDate = new Date(this.policyDegradoPrestazionaleDate.getTime());
  393.         }   
  394.         Long getPolicyDegradoPrestazionaleRequestCounter = this.getPolicyDegradoPrestazionaleRequestCounter(readRemoteInfo);
  395.         if(getPolicyDegradoPrestazionaleRequestCounter!=null){
  396.             dati.policyDegradoPrestazionaleRequestCounter = Long.valueOf(getPolicyDegradoPrestazionaleRequestCounter.longValue()+"");
  397.         }
  398.         Long getPolicyDegradoPrestazionaleCounter = this.getPolicyDegradoPrestazionaleCounter(readRemoteInfo);
  399.         if(getPolicyDegradoPrestazionaleCounter!=null){
  400.             dati.policyDegradoPrestazionaleCounter = Long.valueOf(getPolicyDegradoPrestazionaleCounter.longValue()+"");
  401.         }
  402.         if(this.oldPolicyDegradoPrestazionaleDate!=null){
  403.             dati.oldPolicyDegradoPrestazionaleDate = new Date(this.oldPolicyDegradoPrestazionaleDate.getTime());
  404.         }   
  405.         if(this.oldPolicyDegradoPrestazionaleRequestCounter!=null){
  406.             dati.oldPolicyDegradoPrestazionaleRequestCounter = Long.valueOf(this.oldPolicyDegradoPrestazionaleRequestCounter.longValue()+"");
  407.         }
  408.         if(this.oldPolicyDegradoPrestazionaleCounter!=null){
  409.             dati.oldPolicyDegradoPrestazionaleCounter = Long.valueOf(this.oldPolicyDegradoPrestazionaleCounter.longValue()+"");
  410.         }
  411.         
  412.         
  413.         
  414.         return dati;
  415.     }
  416.     
  417.     private static final String OCCUPAZIONE_BANDA_KB_INFO = " kb (";
  418.     private static final String OCCUPAZIONE_BANDA_BYTES_INFO = " bytes)";
  419.     private static final String TEMPO_COMPLESSIVO_RISPOSTA_SECONDI_INFO = " secondi (";
  420.     private static final String TEMPO_COMPLESSIVO_RISPOSTA_MILLISECONDI_INFO = " ms)";
  421.     private static final String TEMPO_MEDIO_RISPOSTA_MILLISECONDI_INFO = " ms";
  422.         
  423.     @Override
  424.     public String toString(){
  425.         
  426.         SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  427.         
  428.         StringBuilder bf = new StringBuilder();
  429.         
  430.         bf.append("Dati Generali");
  431.         
  432.         // tipo di risorsa
  433.         String nomeRisorsa = null;
  434.         if(this.tipoRisorsa!=null){
  435.             /**bf.append("Risorsa: ");
  436.             bf.append(this.tipoRisorsa.getValue());*/
  437.             nomeRisorsa = this.tipoRisorsa.getValue();
  438.         }
  439.         
  440.         // threads
  441.         if(bf.length()>0){
  442.             bf.append("\n");
  443.         }
  444.         bf.append("\tRichieste Attive: ");
  445.         bf.append(this.getActiveRequestCounter(true));
  446.         
  447.         // data di creazione
  448.         bf.append("\n");
  449.         bf.append("\tData Attivazione Policy: ");
  450.         bf.append(dateformat.format(this.creationDate));
  451.         
  452.         // data di registrazione/aggiornamento policy
  453.         bf.append("\n");
  454.         bf.append("\tData Registrazione/Aggiornamento Policy: ");
  455.         bf.append(dateformat.format(this.updatePolicyDate));
  456.         
  457.         // data di registrazione/aggiornamento policy
  458.         if(this.gestorePolicyConfigDate!=null) {
  459.             bf.append("\n");
  460.             bf.append("\tData Configurazione Gestore Policy: ");
  461.             bf.append(dateformat.format(this.gestorePolicyConfigDate));
  462.         }
  463.         
  464.         // Data now
  465.         Date now = null;
  466.         
  467.         // Policy
  468.         
  469.         Date leftPrecedente = null;
  470.         Date rightPrecedente = null;
  471.         
  472.         if(this.policyDateWindowInterval!=null){
  473.             bf.append("\nDati collezionati per la metrica '"+nomeRisorsa+"'");
  474.             
  475.             if(this.policyRealtime!=null){
  476.                 bf.append("\n");
  477.                 bf.append("\tModalità di Controllo: ");
  478.                 if(this.policyRealtime!=null && this.policyRealtime.booleanValue()){
  479.                     bf.append("realtime");
  480.                 }
  481.                 else{
  482.                     bf.append("statistica");
  483.                 }
  484.             }
  485.             
  486.             bf.append("\n");
  487.             bf.append("\tFinestra Osservazione: ");
  488.             bf.append(this.policyDateWindowInterval.getValue());
  489.             
  490.             // intervallo
  491.             
  492.             Date left = null;
  493.             Date right = null;
  494.             switch (this.policyDateWindowInterval) {
  495.             case CORRENTE:
  496.                 left = this.getLeftDateWindowCurrentInterval();
  497.                 right = this.getRightDateWindowCurrentInterval();
  498.                 break;
  499.             case PRECEDENTE:
  500.                 left = this.getLeftDateWindowCurrentInterval();
  501.                 right = this.getRightDateWindowCurrentInterval();
  502.                 
  503.                 leftPrecedente = this.getLeftDateWindowPrecedentInterval();
  504.                 rightPrecedente = this.getRightDateWindowPrecedentInterval();
  505.                 break;
  506.             case SCORREVOLE:
  507.                 if(now==null){
  508.                     now = DateManager.getDate();
  509.                 }
  510.                 left = this.getLeftDateWindowSlidingInterval(now);
  511.                 right = this.getRightDateWindowSlidingInterval(now);
  512.                 break;
  513.             }
  514.             
  515.             bf.append("\n");
  516.             
  517.             if(left!=null && right!=null){
  518.                 bf.append("\tIntervallo [");
  519.                 bf.append(dateformat.format(left));
  520.                 bf.append(" - ");
  521.                 bf.append(dateformat.format(right));
  522.                 bf.append("]");
  523.             }
  524.             else{
  525.                 if(this.policyDate!=null){
  526.                     bf.append("\tData: ");
  527.                     bf.append(dateformat.format(this.policyDate));
  528.                 }
  529.             }
  530.         }
  531.                     
  532.         Long getPolicyRequestCounter = this.getPolicyRequestCounter(true);
  533.         if(getPolicyRequestCounter!=null){
  534.             bf.append("\n");
  535.             bf.append("\tNumero Richieste Conteggiate: ");
  536.             bf.append(getPolicyRequestCounter);
  537.         }
  538.         Long getPolicyCounter = this.getPolicyCounter(true);
  539.         if(getPolicyCounter!=null){
  540.             bf.append("\n");
  541.             bf.append("\tContatore: ");
  542.             if(this.tipoRisorsa!=null){
  543.                 switch (this.tipoRisorsa) {
  544.                 case NUMERO_RICHIESTE:
  545.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  546.                 case NUMERO_RICHIESTE_FALLITE:
  547.                 case NUMERO_FAULT_APPLICATIVI:
  548.                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  549.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  550.                 case DIMENSIONE_MASSIMA_MESSAGGIO: // non viene usata
  551.                     bf.append(getPolicyCounter);
  552.                     break;
  553.                 case OCCUPAZIONE_BANDA:
  554.                     bf.append(DatiCollezionati.translateToKb(getPolicyCounter));
  555.                     bf.append(OCCUPAZIONE_BANDA_KB_INFO);
  556.                     bf.append(getPolicyCounter);
  557.                     bf.append(OCCUPAZIONE_BANDA_BYTES_INFO);
  558.                     break;
  559.                 case TEMPO_COMPLESSIVO_RISPOSTA:
  560.                     bf.append(DatiCollezionati.translateToSeconds(getPolicyCounter));
  561.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_SECONDI_INFO);
  562.                     bf.append(getPolicyCounter);
  563.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_MILLISECONDI_INFO);
  564.                     break;
  565.                 case TEMPO_MEDIO_RISPOSTA:
  566.                     bf.append(getPolicyCounter);
  567.                     bf.append(TEMPO_MEDIO_RISPOSTA_MILLISECONDI_INFO);
  568.                     break;
  569.                 }
  570.             }
  571.             else{
  572.                 bf.append(getPolicyCounter);
  573.             }
  574.         }
  575.         Double avg = this.getPolicyAvgValue(true);
  576.         if(avg!=null){
  577.             bf.append("\n");
  578.             bf.append("\tValore Medio: ");
  579.             if(this.tipoRisorsa!=null){
  580.                 switch (this.tipoRisorsa) {
  581.                 case NUMERO_RICHIESTE:
  582.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  583.                 case NUMERO_RICHIESTE_FALLITE:
  584.                 case NUMERO_FAULT_APPLICATIVI:
  585.                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  586.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  587.                 case DIMENSIONE_MASSIMA_MESSAGGIO: // non viene usata
  588.                     bf.append(avg.longValue()); 
  589.                     break;
  590.                 case OCCUPAZIONE_BANDA:
  591.                     bf.append(DatiCollezionati.translateToKb(avg.longValue()));
  592.                     bf.append(OCCUPAZIONE_BANDA_KB_INFO);
  593.                     bf.append(avg.longValue());
  594.                     bf.append(OCCUPAZIONE_BANDA_BYTES_INFO);
  595.                     break;
  596.                 case TEMPO_COMPLESSIVO_RISPOSTA:
  597.                     bf.append(DatiCollezionati.translateToSeconds(avg.longValue()));
  598.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_SECONDI_INFO);
  599.                     bf.append(avg.longValue());
  600.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_MILLISECONDI_INFO);
  601.                     break;
  602.                 case TEMPO_MEDIO_RISPOSTA:
  603.                     bf.append(avg.longValue()); 
  604.                     bf.append(TEMPO_MEDIO_RISPOSTA_MILLISECONDI_INFO);
  605.                     break;
  606.                 }
  607.             }
  608.             else{
  609.                 bf.append(avg.longValue()); 
  610.             }
  611.         }
  612.         Long getPolicyDenyRequestCounter = this.getPolicyDenyRequestCounter(true);
  613.         if(getPolicyDenyRequestCounter!=null){
  614.             bf.append("\n");
  615.             bf.append("\tNumero Richieste Bloccate: ");
  616.             bf.append(getPolicyDenyRequestCounter);
  617.         }
  618.         
  619.         if(leftPrecedente!=null && rightPrecedente!=null){
  620.             bf.append("\n");
  621.             bf.append("\tIntervallo Precedente [");
  622.             bf.append(dateformat.format(leftPrecedente));
  623.             bf.append(" - ");
  624.             bf.append(dateformat.format(rightPrecedente));
  625.             bf.append("]");
  626.         }
  627.         
  628.         boolean oldExists = false;
  629.         if(this.oldPolicyRequestCounter!=null){
  630.             oldExists = true;
  631.             bf.append("\n");
  632.             bf.append("\tIntervallo Precedente - Numero Richieste Conteggiate: ");
  633.             bf.append(this.oldPolicyRequestCounter);
  634.         }
  635.         if(this.oldPolicyCounter!=null){
  636.             oldExists = true;
  637.             bf.append("\n");
  638.             bf.append("\tIntervallo Precedente - Contatore: ");
  639.             if(this.tipoRisorsa!=null){
  640.                 switch (this.tipoRisorsa) {
  641.                 case NUMERO_RICHIESTE:
  642.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  643.                 case NUMERO_RICHIESTE_FALLITE:
  644.                 case NUMERO_FAULT_APPLICATIVI:
  645.                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  646.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  647.                 case DIMENSIONE_MASSIMA_MESSAGGIO: // non viene usata
  648.                     bf.append(this.oldPolicyCounter);
  649.                     break;
  650.                 case OCCUPAZIONE_BANDA:
  651.                     bf.append(DatiCollezionati.translateToKb(this.oldPolicyCounter));
  652.                     bf.append(OCCUPAZIONE_BANDA_KB_INFO);
  653.                     bf.append(this.oldPolicyCounter);
  654.                     bf.append(OCCUPAZIONE_BANDA_BYTES_INFO);
  655.                     break;
  656.                 case TEMPO_COMPLESSIVO_RISPOSTA:
  657.                     bf.append(DatiCollezionati.translateToSeconds(this.oldPolicyCounter));
  658.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_SECONDI_INFO);
  659.                     bf.append(this.oldPolicyCounter);
  660.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_MILLISECONDI_INFO);
  661.                     break;
  662.                 case TEMPO_MEDIO_RISPOSTA:
  663.                     bf.append(this.oldPolicyCounter);
  664.                     bf.append(TEMPO_MEDIO_RISPOSTA_MILLISECONDI_INFO);
  665.                     break;
  666.                 }
  667.             }
  668.             else{
  669.                 bf.append(this.oldPolicyCounter);
  670.             }
  671.         }
  672.         Double oldAvg = this.getOldPolicyAvgValue();
  673.         if(oldAvg!=null){
  674.             oldExists = true;
  675.             bf.append("\n");
  676.             bf.append("\tIntervallo Precedente - Valore Medio: ");
  677.             if(this.tipoRisorsa!=null){
  678.                 switch (this.tipoRisorsa) {
  679.                 case NUMERO_RICHIESTE:
  680.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  681.                 case NUMERO_RICHIESTE_FALLITE:
  682.                 case NUMERO_FAULT_APPLICATIVI:
  683.                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  684.                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  685.                 case DIMENSIONE_MASSIMA_MESSAGGIO: // non viene usata
  686.                     bf.append(oldAvg.longValue());  
  687.                     break;
  688.                 case OCCUPAZIONE_BANDA:
  689.                     bf.append(DatiCollezionati.translateToKb(oldAvg.longValue()));  
  690.                     bf.append(OCCUPAZIONE_BANDA_KB_INFO);
  691.                     bf.append(oldAvg.longValue());
  692.                     bf.append(OCCUPAZIONE_BANDA_BYTES_INFO);
  693.                     break;
  694.                 case TEMPO_COMPLESSIVO_RISPOSTA:
  695.                     bf.append(DatiCollezionati.translateToSeconds(oldAvg.longValue())); 
  696.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_SECONDI_INFO);
  697.                     bf.append(oldAvg.longValue());
  698.                     bf.append(TEMPO_COMPLESSIVO_RISPOSTA_MILLISECONDI_INFO);
  699.                     break;
  700.                 case TEMPO_MEDIO_RISPOSTA:
  701.                     bf.append(oldAvg.longValue());  
  702.                     bf.append(TEMPO_MEDIO_RISPOSTA_MILLISECONDI_INFO);
  703.                     break;
  704.                 }
  705.             }
  706.             else{
  707.                 bf.append(oldAvg.longValue());  
  708.             }
  709.         }
  710.         
  711.         if(!oldExists && 
  712.                 this.policyDateWindowInterval!=null &&
  713.                 TipoFinestra.PRECEDENTE.equals(this.policyDateWindowInterval)&&
  714.                 this.policyRealtime!=null && this.policyRealtime.booleanValue()){
  715.             bf.append("\n");
  716.             bf.append("\tIntervallo Precedente - Dati non ancora disponibili");
  717.         }
  718.         
  719.         
  720.         // Degrado
  721.         
  722.         leftPrecedente = null;
  723.         rightPrecedente = null;
  724.         
  725.         if(this.policyDegradoPrestazionaleDateWindowInterval!=null){
  726.             bf.append("\nDati collezionati per Degrado Prestazionale");
  727.                         
  728.             if(this.policyDegradoPrestazionaleRealtime!=null){
  729.                 bf.append("\n");
  730.                 bf.append("\tModalità di Controllo: ");
  731.                 if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime.booleanValue()){
  732.                     bf.append("realtime");
  733.                 }
  734.                 else{
  735.                     bf.append("statistica");
  736.                 }
  737.             }
  738.             
  739.             bf.append("\n");
  740.             bf.append("\tFinestra Osservazione: ");
  741.             bf.append(this.policyDegradoPrestazionaleDateWindowInterval.getValue());
  742.             
  743.             // intervallo
  744.             
  745.             Date left = null;
  746.             Date right = null;
  747.             switch (this.policyDegradoPrestazionaleDateWindowInterval) {
  748.             case CORRENTE:
  749.                 left = this.getDegradoPrestazionaleLeftDateWindowCurrentInterval();
  750.                 right = this.getDegradoPrestazionaleRightDateWindowCurrentInterval();
  751.                 break;
  752.             case PRECEDENTE:
  753.                 
  754.                 left = this.getDegradoPrestazionaleLeftDateWindowCurrentInterval();
  755.                 right = this.getDegradoPrestazionaleRightDateWindowCurrentInterval();
  756.                 
  757.                 leftPrecedente = this.getDegradoPrestazionaleLeftDateWindowPrecedentInterval();
  758.                 rightPrecedente = this.getDegradoPrestazionaleRightDateWindowPrecedentInterval();
  759.                 break;
  760.             case SCORREVOLE:
  761.                 if(now==null){
  762.                     now = DateManager.getDate();
  763.                 }
  764.                 left = this.getDegradoPrestazionaleLeftDateWindowSlidingInterval(now);
  765.                 right = this.getDegradoPrestazionaleRightDateWindowSlidingInterval(now);
  766.                 break;
  767.             }
  768.             
  769.             bf.append("\n");
  770.             
  771.             if(left!=null && right!=null){
  772.                 bf.append("\tIntervallo [");
  773.                 bf.append(dateformat.format(left));
  774.                 bf.append(" - ");
  775.                 bf.append(dateformat.format(right));
  776.                 bf.append("]");
  777.             }
  778.             else{
  779.                 if(this.policyDegradoPrestazionaleDate!=null){
  780.                     bf.append("\tData: ");
  781.                     bf.append(dateformat.format(this.policyDegradoPrestazionaleDate));
  782.                 }
  783.             }
  784.         }
  785.                 
  786.         Long getPolicyDegradoPrestazionaleRequestCounter = this.getPolicyDegradoPrestazionaleRequestCounter(true);
  787.         if(getPolicyDegradoPrestazionaleRequestCounter!=null){
  788.             bf.append("\n");
  789.             bf.append("\tNumeroRichieste: ");
  790.             bf.append(getPolicyDegradoPrestazionaleRequestCounter);
  791.         }
  792.         Long getPolicyDegradoPrestazionaleCounter = this.getPolicyDegradoPrestazionaleCounter(true);
  793.         if(getPolicyDegradoPrestazionaleCounter!=null){
  794.             bf.append("\n");
  795.             bf.append("\tContatore: ");
  796.             bf.append(getPolicyDegradoPrestazionaleCounter);
  797.             bf.append(" ms");
  798.         }
  799.         Double avgDegradoPrestazionale = this.getPolicyDegradoPrestazionaleAvgValue(true);
  800.         if(avgDegradoPrestazionale!=null){
  801.             bf.append("\n");
  802.             bf.append("\tValore Medio: ");
  803.             bf.append(avgDegradoPrestazionale.longValue()); 
  804.             bf.append(" ms");
  805.         }
  806.         
  807.         if(leftPrecedente!=null && rightPrecedente!=null){
  808.             bf.append("\n");
  809.             bf.append("\tIntervallo Precedente [");
  810.             bf.append(dateformat.format(leftPrecedente));
  811.             bf.append(" - ");
  812.             bf.append(dateformat.format(rightPrecedente));
  813.             bf.append("]");
  814.         }
  815.         
  816.         boolean oldDegradoPrestazionaleExists = false;
  817.         if(this.oldPolicyDegradoPrestazionaleRequestCounter!=null){
  818.             oldDegradoPrestazionaleExists = true;
  819.             bf.append("\n");
  820.             bf.append("\tIntervallo Precedente - Numero Richieste: ");
  821.             bf.append(this.oldPolicyDegradoPrestazionaleRequestCounter);
  822.         }
  823.         if(this.oldPolicyDegradoPrestazionaleCounter!=null){
  824.             oldDegradoPrestazionaleExists = true;
  825.             bf.append("\n");
  826.             bf.append("\tIntervallo Precedente - Contatore: ");
  827.             bf.append(this.oldPolicyDegradoPrestazionaleCounter);
  828.             bf.append(" ms");
  829.         }
  830.         Double oldAvgDegradoPrestazionale = this.getOldPolicyDegradoPrestazionaleAvgValue();
  831.         if(oldAvgDegradoPrestazionale!=null){
  832.             oldDegradoPrestazionaleExists = true;
  833.             bf.append("\n");
  834.             bf.append("\tIntervallo Precedente - Valore Medio: ");
  835.             bf.append(oldAvgDegradoPrestazionale.longValue());  
  836.             bf.append(" ms");
  837.         }
  838.         
  839.         if(!oldDegradoPrestazionaleExists && 
  840.                 this.policyDegradoPrestazionaleDateWindowInterval!=null &&
  841.                 TipoFinestra.PRECEDENTE.equals(this.policyDegradoPrestazionaleDateWindowInterval) &&
  842.             this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime.booleanValue()){
  843.             bf.append("\n");
  844.             bf.append("\tIntervallo Precedente - Dati non ancora disponibili");
  845.         }
  846.         

  848.         
  849.         return bf.toString();
  850.     }
  851.     
  852.     

  854.     protected boolean isRisorsaContaNumeroRichieste(TipoRisorsa tipoRisorsa) {
  855.         switch (tipoRisorsa) {
  856.         case NUMERO_RICHIESTE:
  857.         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  858.         case NUMERO_RICHIESTE_FALLITE:
  859.         case NUMERO_FAULT_APPLICATIVI:
  860.         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  861.         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  862.             return true;
  863.         case OCCUPAZIONE_BANDA:
  864.         case TEMPO_COMPLESSIVO_RISPOSTA:
  865.         case TEMPO_MEDIO_RISPOSTA:
  866.         case DIMENSIONE_MASSIMA_MESSAGGIO: // non viene usata
  867.             return false;
  868.         }
  869.         return false;
  870.     }
  871.     
  872.     
  873.     protected boolean isRisorsaContaNumeroRichiesteDipendentiEsito(TipoRisorsa tipoRisorsa) {
  874.         switch (tipoRisorsa) {
  875.         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  876.         case NUMERO_RICHIESTE_FALLITE:
  877.         case NUMERO_FAULT_APPLICATIVI:
  878.         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  879.         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  880.             return true;
  881.         case NUMERO_RICHIESTE:
  882.         case OCCUPAZIONE_BANDA:
  883.         case TEMPO_COMPLESSIVO_RISPOSTA:
  884.         case TEMPO_MEDIO_RISPOSTA:
  885.         case DIMENSIONE_MASSIMA_MESSAGGIO: // non viene usata
  886.             return false;
  887.         }
  888.         return false;
  889.     }
  890.     

  892.     protected void resetPolicyCounterForDate(Date d) {
  893.         this.policyDate = d;
  894.         if(this.policyRealtime!=null && this.policyRealtime){
  895.             this.policyRequestCounter = 0l;
  896.             this.policyDenyRequestCounter = 0l;
  897.             if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  898.                 /**SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  899.                 System.out.println("Resetto policy counter a zero per intervallo d["+dateformat.format(d)+"]");*/
  900.                 this.policyCounter = 0l;
  901.             }
  902.         }
  903.     }
  904.     
  905.     
  906.     protected void resetPolicyCounterForDateDegradoPrestazionale(Date d) {
  907.         this.policyDegradoPrestazionaleDate = d;
  908.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  909.             this.policyDegradoPrestazionaleRequestCounter = 0l;
  910.             this.policyDegradoPrestazionaleCounter = 0l;
  911.         }
  912.         
  913.     }
  914.     
  915.     protected void logDebug(Logger log, String msg) {
  916.         if(log!=null) {
  917.             log.debug(msg);
  918.         }
  919.     }
  920.     
  921.     protected void checkPolicyCounterForDate(Logger log, ActivePolicy activePolicy){
  922.         
  923.         if(this.policyDate==null){
  924.             // first-init
  925.             resetPolicyCounterForDate(DateUtils.convertToLeftInterval(DateManager.getDate(),this.policyDateTypeInterval));
  926.             
  927.             if(this.policyRealtime!=null && !this.policyRealtime){
  928.                 // statistico. Serve subito anche l'intervallo precedente
  929.                 this.oldPolicyDate = DateUtils.incrementDate(this.policyDate, this.policyDateTypeInterval, this.policyDateInterval*(-1));
  930.             }
  931.             
  932.         }
  933.         
  934.         else{
  935.             
  936.             Date rightInterval = this.getRightDateWindowCurrentInterval();
  937.             Date now = DateManager.getDate();

  939.             boolean after = now.after(rightInterval);
  940.             if(activePolicy.getConfigurazioneControlloTraffico().isDebug()){
  941.                 SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  942.                 logDebug(log,"checkPolicyCounterForDate now["+dateformat.format(now)+"] after policyDate["+dateformat.format(rightInterval)+"]: "+after+"");
  943.             }
  944.             if(after){
  945.                 
  946.                 if(TipoFinestra.PRECEDENTE.equals(this.getPolicyDateWindowInterval())){
  947.                     // Salvo old
  948.                     this.oldPolicyDate = this.policyDate;
  949.                     if(this.policyRealtime!=null && this.policyRealtime){
  950.                         this.oldPolicyRequestCounter = this.policyRequestCounter;
  951.                         if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  952.                             this.oldPolicyCounter = this.policyCounter;
  953.                         }
  954.                     }
  955.                 }
  956.                 
  957.                 // Genero nuova finestra
  958.                 Date d = DateUtils.incrementDate(this.policyDate, this.policyDateTypeInterval, this.policyDateInterval);
  959.                 
  960.                 Date dRight = DateUtils.convertToRightInterval(d, this.policyDateTypeInterval);
  961.                 dRight = DatiCollezionati.incrementDate(dRight, this.policyDateTypeInterval, this.policyDateInterval, this.policyDateCurrentInterval);
  962.                 /**Date dRight = DateUtils.incrementDate(d, this.policyDateTypeInterval, this.policyDateInterval);
  963.                 dRight = DateUtils.convertToRightInterval(dRight, this.policyDateTypeInterval);*/
  964.                 
  965.                 boolean before = dRight.before(now);
  966.                 if(activePolicy.getConfigurazioneControlloTraffico().isDebug()){
  967.                     SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  968.                     logDebug(log,"checkPolicyCounterForDate Increment d["+dateformat.format(d)+"] dRight["+dateformat.format(dRight)+"] before now["+
  969.                             dateformat.format(now)+"]: "+before);
  970.                 }
  971.                 while(before){
  972.                     
  973.                     // la nuova richiesta non riguarda l'intervallo+1 rispetto al precedente, ma intervalli successivi.
  974.                     // Devo resettare anche i vecchi contatori
  975.                     if(TipoFinestra.PRECEDENTE.equals(this.getPolicyDateWindowInterval())){             
  976.                         // Salvo old
  977.                         this.oldPolicyDate = d;
  978.                         if(this.policyRealtime!=null && this.policyRealtime){
  979.                             this.oldPolicyRequestCounter = 0l;
  980.                             if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  981.                                 this.oldPolicyCounter = 0l;
  982.                             }
  983.                         }
  984.                     }
  985.                     
  986.                     d = DateUtils.incrementDate(d, this.policyDateTypeInterval, this.policyDateInterval);
  987.                     
  988.                     dRight = DateUtils.convertToRightInterval(d, this.policyDateTypeInterval);
  989.                     dRight = DatiCollezionati.incrementDate(dRight, this.policyDateTypeInterval, this.policyDateInterval, this.policyDateCurrentInterval);
  990.                     /**dRight = DateUtils.incrementDate(d, this.policyDateTypeInterval, this.policyDateInterval);
  991.                     dRight = DateUtils.convertToRightInterval(dRight, this.policyDateTypeInterval);*/
  992.                     
  993.                     before = dRight.before(now);
  994.                     if(activePolicy.getConfigurazioneControlloTraffico().isDebug()){
  995.                         SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  996.                         logDebug(log,"checkPolicyCounterForDate Increment d["+dateformat.format(d)+"] dRight["+dateformat.format(dRight)+"] before now["+
  997.                                 dateformat.format(now)+"]: "+before);
  998.                     }
  999.                 }
  1000.                 
  1001.                 resetPolicyCounterForDate(d);
  1002.                 
  1003.             } 
  1004.             
  1005.         }
  1006.                 
  1007.     }
  1008.     

  1010.     protected void checkPolicyCounterForDateDegradoPrestazionale(Logger log, ActivePolicy activePolicy){
  1011.         
  1012.         if(this.policyDegradoPrestazionaleDate==null){
  1013.             
  1014.             // first-init
  1015.             resetPolicyCounterForDateDegradoPrestazionale(DateUtils.convertToLeftInterval(DateManager.getDate(),this.policyDegradoPrestazionaleDateTypeInterval));
  1016.             
  1017.             if(this.policyDegradoPrestazionaleRealtime!=null && !this.policyDegradoPrestazionaleRealtime){
  1018.                 // statistico. Serve subito anche l'intervallo precedente
  1019.                 this.oldPolicyDegradoPrestazionaleDate = DateUtils.incrementDate(this.policyDegradoPrestazionaleDate, 
  1020.                         this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval*(-1));
  1021.             }
  1022.             
  1023.         }
  1024.         
  1025.         else{
  1026.             
  1027.             Date rightInterval = this.getDegradoPrestazionaleRightDateWindowCurrentInterval();
  1028.             Date now = DateManager.getDate();

  1030.             boolean after = now.after(rightInterval);
  1031.             if(activePolicy.getConfigurazioneControlloTraffico().isDebug()){
  1032.                 SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  1033.                 logDebug(log,"checkPolicyCounterForDateDegradoPrestazionale now["+dateformat.format(now)+"] after policyDate["+dateformat.format(rightInterval)+"]: "+after+"");
  1034.             }
  1035.             if(after){
  1036.                 
  1037.                 if(TipoFinestra.PRECEDENTE.equals(this.getPolicyDegradoPrestazionaleDateWindowInterval())){             
  1038.                     // Salvo old
  1039.                     this.oldPolicyDegradoPrestazionaleDate = this.policyDegradoPrestazionaleDate;
  1040.                     if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  1041.                         this.oldPolicyDegradoPrestazionaleRequestCounter = this.policyDegradoPrestazionaleRequestCounter;
  1042.                         this.oldPolicyDegradoPrestazionaleCounter = this.policyDegradoPrestazionaleCounter;
  1043.                     }
  1044.                 }
  1045.                 
  1046.                 // Genero nuova finestra
  1047.                 Date d = DateUtils.incrementDate(this.policyDegradoPrestazionaleDate, this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval);
  1048.                 Date dRight = DateUtils.incrementDate(d, this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval);
  1049.                 dRight = DateUtils.convertToRightInterval(dRight, this.policyDegradoPrestazionaleDateTypeInterval);
  1050.                 boolean before = dRight.before(now);
  1051.                 if(activePolicy.getConfigurazioneControlloTraffico().isDebug()){
  1052.                     SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  1053.                     logDebug(log,"checkPolicyCounterForDateDegradoPrestazionale Increment d["+dateformat.format(d)+"] dRight["+dateformat.format(dRight)+"] before now["+
  1054.                             dateformat.format(now)+"]: "+before);
  1055.                 }
  1056.                 while(before){
  1057.                     
  1058.                     // la nuova richiesta non riguarda l'intervallo+1 rispetto al precedente, ma intervalli successivi.
  1059.                     // Devo resettare anche i vecchi contatori
  1060.                     if(TipoFinestra.PRECEDENTE.equals(this.getPolicyDegradoPrestazionaleDateWindowInterval())){             
  1061.                         // Salvo old
  1062.                         this.oldPolicyDegradoPrestazionaleDate = d;
  1063.                         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  1064.                             this.oldPolicyDegradoPrestazionaleRequestCounter = 0l;
  1065.                             this.oldPolicyDegradoPrestazionaleCounter = 0l;
  1066.                         }
  1067.                     }
  1068.                     
  1069.                     d = DateUtils.incrementDate(d, this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval);
  1070.                     dRight = DateUtils.incrementDate(d, this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval);
  1071.                     dRight = DateUtils.convertToRightInterval(dRight, this.policyDegradoPrestazionaleDateTypeInterval);
  1072.                     before = dRight.before(now);
  1073.                     if(activePolicy.getConfigurazioneControlloTraffico().isDebug()){
  1074.                         SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  1075.                         logDebug(log,"checkPolicyCounterForDateDegradoPrestazionale Increment d["+dateformat.format(d)+"] dRight["+dateformat.format(dRight)+"] before now["+
  1076.                                 dateformat.format(now)+"]: "+before);
  1077.                     }
  1078.                 }
  1079.                 resetPolicyCounterForDateDegradoPrestazionale(d);
  1080.             } 
  1081.             
  1082.         }
  1083.                 
  1084.     }
  1085.     
  1086.     // Questo metodo viene chiamato dai metodi 'resetCounters' degli oggetti PolicyGroupByActiveThreads che a sua volta sono invocabili solamente via Jmx/Console
  1087.     public void resetCounters(){
  1088.         this.resetCounters(null);
  1089.         
  1090.         this.manuallyResetPolicyTimeMillis = DateManager.getTimeMillis();
  1091.         /**System.out.println("IMPOSTO RESET MANUALE ("+this.manuallyResetPolicyTimeMillis+") IN ["+this.toString()+"]");*/
  1092.         
  1093.     }
  1094.     // Questo metodo viene invocato quando viene rilevata una modifica ai valori di soglia di una policy e quindi viene aggiornata l'updatePolicyDate
  1095.     // In questo metodo non serve registrare il manuallyResetPolicyTimeMillis poichè il metodo viene invocato sempre prima di una 'registerStartRequest' mentre la funzione del manuallyResetPolicyTimeMillis
  1096.     // serve ad ignorare la gestione successiva ad un reset counter per le transazioni in corso.
  1097.     public void resetCounters(Date updatePolicyDate){
  1098.         
  1099.         if(updatePolicyDate!=null) {
  1100.             this.updatePolicyDate = updatePolicyDate;
  1101.         }
  1102.         
  1103.         if(this.policyRequestCounter!=null){
  1104.             this.policyRequestCounter = 0l;
  1105.         }
  1106.         if(this.policyCounter!=null){
  1107.             this.policyCounter = 0l;
  1108.         }
  1109.         if(this.policyDenyRequestCounter!=null){
  1110.             this.policyDenyRequestCounter = 0l;
  1111.         }
  1112.         this.oldPolicyDate = null;
  1113.         if(this.oldPolicyRequestCounter!=null){
  1114.             this.oldPolicyRequestCounter = 0l;
  1115.         }
  1116.         if(this.oldPolicyCounter!=null){
  1117.             this.oldPolicyCounter = 0l;
  1118.         }
  1119.         
  1120.         if(this.policyDegradoPrestazionaleRequestCounter!=null){
  1121.             this.policyDegradoPrestazionaleRequestCounter = 0l;
  1122.         }
  1123.         if(this.policyDegradoPrestazionaleCounter!=null){
  1124.             this.policyDegradoPrestazionaleCounter = 0l;
  1125.         }
  1126.         this.oldPolicyDegradoPrestazionaleDate = null;
  1127.         if(this.oldPolicyDegradoPrestazionaleRequestCounter!=null){
  1128.             this.oldPolicyDegradoPrestazionaleRequestCounter = 0l;
  1129.         }
  1130.         if(this.oldPolicyDegradoPrestazionaleCounter!=null){
  1131.             this.oldPolicyDegradoPrestazionaleCounter = 0l;
  1132.         }
  1133.         
  1134.     }
  1135.     
  1136.     public void checkDate(Logger log, ActivePolicy activePolicy){
  1137.         
  1138.         if(this.creationDate==null){
  1139.             this.initDatiIniziali(activePolicy);
  1140.         }
  1141.         
  1142.         if(this.getPolicyDateWindowInterval()!=null && 
  1143.                 !TipoFinestra.SCORREVOLE.equals(this.getPolicyDateWindowInterval())){
  1144.             
  1145.             this.checkPolicyCounterForDate(log,activePolicy);
  1146.             
  1147.         }
  1148.         
  1149.         if(this.getPolicyDegradoPrestazionaleDateWindowInterval()!=null && 
  1150.                 !TipoFinestra.SCORREVOLE.equals(this.getPolicyDegradoPrestazionaleDateWindowInterval())){
  1151.             
  1152.             this.checkPolicyCounterForDateDegradoPrestazionale(log,activePolicy);

  1154.         }
  1155.         
  1156.     }
  1157.     
  1158.     
  1159.     private boolean skipBecauseManuallyResetAfterStartRequest(String source, Map<Object> ctx) {
  1160.         if(source!=null) {
  1161.             // nop
  1162.         }
  1163.         if(this.manuallyResetPolicyTimeMillis!=null && ctx!=null) {
  1164.             Object o = ctx.get(START_PROCESS_REQUEST_TIME_MS);
  1165.             if(o==null) {
  1166.                 // transazione gestita precedentemente al reset dei contatori
  1167.                 /**System.out.println("@"+source+" RILEVATO RESET '"+this.manuallyResetPolicyTimeMillis+"', trovato in ctx 'NULL'");*/
  1168.                 return true;
  1169.             }
  1170.             Long l = (Long) o;
  1171.             if(l.longValue() < this.manuallyResetPolicyTimeMillis.longValue()) {
  1172.                 // transazione gestita precedentemente al reset dei contatori
  1173.                 /**System.out.println("@"+source+" RILEVATO RESET '"+this.manuallyResetPolicyTimeMillis+"', trovato in ctx una data minore '"+l+"'");*/
  1174.                 return true;
  1175.             }
  1176.         }
  1177.         return false;
  1178.     }
  1179.     
  1180.     
  1181.     
  1182.     protected void internalRegisterStartRequestIncrementActiveRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  1183.         this.activeRequestCounter++;
  1184.         if(datiCollezionatiPerPolicyVerifier!=null) {
  1185.             datiCollezionatiPerPolicyVerifier.activeRequestCounter = this.activeRequestCounter;
  1186.         }
  1187.     }
  1188.     public void registerStartRequest(Logger log, ActivePolicy activePolicy, Map<Object> ctx){
  1189.         registerStartRequest(log, activePolicy, ctx, null);
  1190.     }
  1191.     public void registerStartRequest(Logger log, ActivePolicy activePolicy, Map<Object> ctx, DatiCollezionati datiCollezionatiPerPolicyVerifier){
  1192.         
  1193.         if(this.creationDate==null){
  1194.             this.initDatiIniziali(activePolicy);
  1195.         }
  1196.         
  1197.         internalRegisterStartRequestIncrementActiveRequestCounter(datiCollezionatiPerPolicyVerifier);
  1198.         
  1199.         if(this.getPolicyDateWindowInterval()!=null && 
  1200.                 !TipoFinestra.SCORREVOLE.equals(this.getPolicyDateWindowInterval())){
  1201.             
  1202.             this.checkPolicyCounterForDate(log,activePolicy);
  1203.                         
  1204.         }

  1206.         if(this.getPolicyDegradoPrestazionaleDateWindowInterval()!=null && 
  1207.                 !TipoFinestra.SCORREVOLE.equals(this.getPolicyDegradoPrestazionaleDateWindowInterval())){
  1208.             
  1209.             this.checkPolicyCounterForDateDegradoPrestazionale(log,activePolicy);
  1210.             
  1211.             /**if(this.policyDegradoPrestazionaleRealtime){
  1212.             // Essendo il degrado un tempo medio anche il numero di richieste lo devo incrementare quando aggiungo anche la latenza, 
  1213.             // senno poi la divisione (per l'avg) rispetto al numero di richieste è falsata
  1214.             // poiche' tengo conto anche delle richieste in corso, nonostante per queste non disponga ancora nella latenza
  1215.             }*/
  1216.         }
  1217.         
  1218.         if(this.manuallyResetPolicyTimeMillis!=null && ctx!=null) {
  1219.             ctx.put(START_PROCESS_REQUEST_TIME_MS, DateManager.getTimeMillis());
  1220.             /**System.out.println("IMPOSTATO IN CONTESTO: '"+DateManager.getTimeMillis()+"'");*/
  1221.         }
  1222.     }
  1223.     
  1224.     protected void internalUpdateDatiStartRequestApplicabileIncrementRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  1225.         this.policyRequestCounter++;
  1226.         if(datiCollezionatiPerPolicyVerifier!=null) {
  1227.             datiCollezionatiPerPolicyVerifier.policyRequestCounter = this.policyRequestCounter;
  1228.         }
  1229.     }
  1230.     public boolean updateDatiStartRequestApplicabile(Logger log, ActivePolicy activePolicy, Map<Object> ctx){
  1231.         return updateDatiStartRequestApplicabile(log, activePolicy, ctx, null);
  1232.     }
  1233.     public boolean updateDatiStartRequestApplicabile(Logger log, ActivePolicy activePolicy, Map<Object> ctx, DatiCollezionati datiCollezionatiPerPolicyVerifier){
  1234.         
  1235.         if(log!=null) {
  1236.             // nop
  1237.         }
  1238.         
  1239.         if(skipBecauseManuallyResetAfterStartRequest("updateDatiStartRequestApplicabile", ctx)) {
  1240.             return false;
  1241.         }
  1242.         
  1243.         if(this.getPolicyDateWindowInterval()!=null && 
  1244.                 !TipoFinestra.SCORREVOLE.equals(this.getPolicyDateWindowInterval()) &&
  1245.                 (this.policyRealtime!=null && this.policyRealtime.booleanValue() &&
  1246.                 // il contatore delle richieste lo tengo per qualsiasi tipo di risorsa
  1247.                 // Pero' per il tempo medio lo devo incrementare quando aggiungo anche la latenza, senno poi la divisione (per l'avg) rispetto al numero di richieste è falsata
  1248.                 // poiche' tengo conto anche delle richieste in corso, nonostante per queste non disponga ancora nella latenza
  1249.                 // Lo stesso per le richieste che dipendono dall'esito devo incrementarle solo quando conosco l'esito della transazione
  1250.                 ( (!TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(activePolicy.getTipoRisorsaPolicy())) &&
  1251.                         !isRisorsaContaNumeroRichiesteDipendentiEsito(activePolicy.getTipoRisorsaPolicy()))
  1252.                 )
  1253.             ){
  1254.             internalUpdateDatiStartRequestApplicabileIncrementRequestCounter(datiCollezionatiPerPolicyVerifier);
  1255.             return true;
  1256.             
  1257.         }
  1258.         
  1259.         return false;

  1261.     }
  1262.     
  1263.     protected void internalRegisterEndRequestDecrementActiveRequestCounter() {
  1264.         this.activeRequestCounter--;
  1265.     }
  1266.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleRequestCounter() {
  1267.         this.policyDegradoPrestazionaleRequestCounter++;
  1268.     }
  1269.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleCounter(long latenza) {
  1270.         this.policyDegradoPrestazionaleCounter = this.policyDegradoPrestazionaleCounter + latenza;
  1271.     }
  1272.     public void registerEndRequest(Logger log, ActivePolicy activePolicy, Map<Object> ctx, MisurazioniTransazione dati){
  1273.         
  1274.         if(log!=null) {
  1275.             // nop
  1276.         }
  1277.         if(this.creationDate==null){
  1278.             return; // non inizializzato?
  1279.         }
  1280.         
  1281.         internalRegisterEndRequestDecrementActiveRequestCounter();
  1282.                 
  1283.         // Il decrement delle richieste attive deve comunque essere attuato poichè il reset dei contatori non insiste sul numero di richieste attive
  1284.         if(skipBecauseManuallyResetAfterStartRequest("registerEndRequest", ctx)) {
  1285.             return;
  1286.         }
  1287.         
  1288.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  1289.             
  1290.             long latenza = 0;
  1291.             
  1292.             int [] esitiValidi = null;
  1293.             
  1294.             if(TipoPdD.DELEGATA.equals(dati.getTipoPdD())){
  1295.                 esitiValidi = activePolicy.getConfigurazioneControlloTraffico().getCalcoloLatenzaPortaDelegataEsitiConsiderati().get(dati.getProtocollo());
  1296.             }
  1297.             else{
  1298.                 esitiValidi = activePolicy.getConfigurazioneControlloTraffico().getCalcoloLatenzaPortaApplicativaEsitiConsiderati().get(dati.getProtocollo());
  1299.             }
  1300.             boolean found = false;
  1301.             for (int esitoValido : esitiValidi) {
  1302.                 if(dati.getEsitoTransazione() == esitoValido){
  1303.                     latenza = this.getLatenza(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeTipoLatenza(), dati);
  1304.                     found = true;
  1305.                     break;
  1306.                 }
  1307.             }
  1308.             
  1309.             if(found){
  1310.                 internalRegisterEndRequestIncrementDegradoPrestazionaleRequestCounter();
  1311.                 internalRegisterEndRequestIncrementDegradoPrestazionaleCounter(latenza);
  1312.             }
  1313.             
  1314.         }
  1315.     }
  1316.     
  1317.     protected void internalUpdateDatiEndRequestApplicabileIncrementRequestCounter() {
  1318.         this.policyRequestCounter++;
  1319.     }
  1320.     protected void internalUpdateDatiEndRequestApplicabileDecrementRequestCounter() {
  1321.         this.policyRequestCounter--;
  1322.     }
  1323.     protected void internalUpdateDatiEndRequestApplicabileIncrementDenyRequestCounter() {
  1324.         this.policyDenyRequestCounter++;
  1325.     }
  1326.     protected void internalUpdateDatiEndRequestApplicabileIncrementCounter(long v) {
  1327.         this.policyCounter = this.policyCounter + v;
  1328.     }
  1329.     public void updateDatiEndRequestApplicabile(Logger log, ActivePolicy activePolicy, Map<Object> ctx,
  1330.             MisurazioniTransazione dati,
  1331.             List<Integer> esitiCodeOk, List<Integer> esitiCodeKoSenzaFaultApplicativo, List<Integer> esitiCodeFaultApplicativo, 
  1332.             boolean isViolata) throws PolicyException{
  1333.         
  1334.         if(log!=null) {
  1335.             // nop
  1336.         }
  1337.         if(skipBecauseManuallyResetAfterStartRequest("updateDatiEndRequestApplicabile", ctx)) {
  1338.             return;
  1339.         }
  1340.         
  1341.         if(this.policyRealtime!=null && this.policyRealtime){
  1342.         
  1343.             int [] esitiPolicyViolate = activePolicy.getConfigurazioneControlloTraffico().getEsitiPolicyViolate().get(dati.getProtocollo());
  1344.             boolean foundEsitoDeny = false;
  1345.             for (int esitoViolato : esitiPolicyViolate) {
  1346.                 if(dati.getEsitoTransazione() == esitoViolato){
  1347.                     foundEsitoDeny = true;
  1348.                     break;
  1349.                 }
  1350.             }
  1351.             
  1352.             if(foundEsitoDeny){
  1353.                 if( (!TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(activePolicy.getTipoRisorsaPolicy())) &&
  1354.                         !isRisorsaContaNumeroRichiesteDipendentiEsito(activePolicy.getTipoRisorsaPolicy())){                
  1355.                     internalUpdateDatiEndRequestApplicabileDecrementRequestCounter(); // l'avevo incrementato nello start
  1356.                 }
  1357.                 if(isViolata) {
  1358.                     // Aumento solamente il contatore della policy la quale ha bloccato la transazione
  1359.                     internalUpdateDatiEndRequestApplicabileIncrementDenyRequestCounter();
  1360.                 }
  1361.                 return; // non incremento alcun contatore.
  1362.             }
  1363.             
  1364.             
  1365.             switch (activePolicy.getTipoRisorsaPolicy()) {
  1366.             
  1367.             case DIMENSIONE_MASSIMA_MESSAGGIO:
  1368.                 
  1369.                 // nop
  1370.                 
  1371.                 break;          
  1372.             
  1373.             case NUMERO_RICHIESTE:
  1374.                 
  1375.                 // nop
  1376.                 
  1377.                 break;
  1378.                 
  1379.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  1380.             case NUMERO_RICHIESTE_FALLITE:
  1381.             case NUMERO_FAULT_APPLICATIVI:
  1382.             case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  1383.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:               
  1384.                 
  1385.                 List<Integer> esitiAppartenentiGruppo = null;
  1386.                 try {
  1387.                     if(TipoRisorsa.NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO.equals(activePolicy.getTipoRisorsaPolicy())) {
  1388.                         /**esitiAppartenentiGruppo = EsitiProperties.getInstance(log).getEsitiCodeOk();*/
  1389.                         esitiAppartenentiGruppo = esitiCodeOk;
  1390.                     }
  1391.                     else if(TipoRisorsa.NUMERO_RICHIESTE_FALLITE.equals(activePolicy.getTipoRisorsaPolicy())) {
  1392.                         /**esitiAppartenentiGruppo = EsitiProperties.getInstance(log).getEsitiCodeKo_senzaFaultApplicativo();*/
  1393.                         esitiAppartenentiGruppo = esitiCodeKoSenzaFaultApplicativo;
  1394.                     }
  1395.                     else if(TipoRisorsa.NUMERO_FAULT_APPLICATIVI.equals(activePolicy.getTipoRisorsaPolicy())) {
  1396.                         /**esitiAppartenentiGruppo = EsitiProperties.getInstance(log).getEsitiCodeFaultApplicativo();*/
  1397.                         esitiAppartenentiGruppo = esitiCodeFaultApplicativo;
  1398.                     }
  1399.                     else if(TipoRisorsa.NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI.equals(activePolicy.getTipoRisorsaPolicy())) {
  1400.                         esitiAppartenentiGruppo = new ArrayList<>();
  1401.                         esitiAppartenentiGruppo.addAll(esitiCodeKoSenzaFaultApplicativo);
  1402.                         esitiAppartenentiGruppo.addAll(esitiCodeFaultApplicativo);
  1403.                     }
  1404.                     else {
  1405.                         // NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI
  1406.                         esitiAppartenentiGruppo = new ArrayList<>();
  1407.                         esitiAppartenentiGruppo.addAll(esitiCodeOk);
  1408.                         esitiAppartenentiGruppo.addAll(esitiCodeFaultApplicativo);
  1409.                     }
  1410.                 }catch(Exception e) {
  1411.                     throw new PolicyException(e.getMessage(),e);
  1412.                 }
  1413.                 for (int esitoAppartenenteGruppo : esitiAppartenentiGruppo) {
  1414.                     if(dati.getEsitoTransazione() == esitoAppartenenteGruppo){
  1415.                         internalUpdateDatiEndRequestApplicabileIncrementRequestCounter();
  1416.                         break;
  1417.                     }
  1418.                 }
  1419.                 break;
  1420.                 
  1421.             case OCCUPAZIONE_BANDA:
  1422.                 
  1423.                 // viene misurata la banda "generata" dalle applicazioni
  1424.                 /**System.out.println("Incremento banda da "+this.policyCounter);*/
  1425.                 long banda = this.getBanda(activePolicy.getConfigurazionePolicy().getValoreTipoBanda(), dati);
  1426.                 internalUpdateDatiEndRequestApplicabileIncrementCounter(banda);
  1427.                 /**System.out.println("Incremento banda a "+this.policyCounter);*/
  1428.                                 
  1429.                 break;
  1430.     
  1431.                 
  1432.             case TEMPO_COMPLESSIVO_RISPOSTA:
  1433.             case TEMPO_MEDIO_RISPOSTA:
  1434.                 
  1435.                 int [] esitiValidi = null;
  1436.                 
  1437.                 if(TipoPdD.DELEGATA.equals(dati.getTipoPdD())){
  1438.                     esitiValidi = activePolicy.getConfigurazioneControlloTraffico().getCalcoloLatenzaPortaDelegataEsitiConsiderati().get(dati.getProtocollo());
  1439.                 }
  1440.                 else{
  1441.                     esitiValidi = activePolicy.getConfigurazioneControlloTraffico().getCalcoloLatenzaPortaApplicativaEsitiConsiderati().get(dati.getProtocollo());
  1442.                 }
  1443.                 boolean found = false;
  1444.                 for (int esitoValido : esitiValidi) {
  1445.                     if(dati.getEsitoTransazione() == esitoValido){
  1446.                         long latenza = this.getLatenza(activePolicy.getConfigurazionePolicy().getValoreTipoLatenza(), dati);
  1447.                         /**System.out.println("Incremento tempo da "+this.policyCounter);*/
  1448.                         internalUpdateDatiEndRequestApplicabileIncrementCounter(latenza);
  1449.                         /**System.out.println("Incremento tempo a "+this.policyCounter);*/
  1450.                         found = true;
  1451.                         break;
  1452.                     }
  1453.                 }
  1454.             
  1455.                 if(found && TipoRisorsa.TEMPO_MEDIO_RISPOSTA.equals(activePolicy.getTipoRisorsaPolicy())){
  1456.                     internalUpdateDatiEndRequestApplicabileIncrementRequestCounter(); 
  1457.                 }
  1458.                 
  1459.                 break;
  1460.             }
  1461.         }
  1462.             
  1463.                     
  1464.     }
  1465.     
  1466.     protected long getLatenza(TipoLatenza tipoLatenza, MisurazioniTransazione dati){
  1467.         long latenza = 0;
  1468.         switch (tipoLatenza) {
  1469.         case TOTALE:
  1470.             if(dati.getDataUscitaRisposta()!=null && dati.getDataIngressoRichiesta()!=null){
  1471.                 latenza = dati.getDataUscitaRisposta().getTime()-dati.getDataIngressoRichiesta().getTime();
  1472.             }
  1473.             break;
  1474.         case SERVIZIO:
  1475.             if(dati.getDataUscitaRichiesta()!=null && dati.getDataIngressoRisposta()!=null){
  1476.                 latenza = dati.getDataIngressoRisposta().getTime()-dati.getDataUscitaRichiesta().getTime();
  1477.             }
  1478.             break;
  1479.         case PORTA:
  1480.             if(dati.getDataUscitaRichiesta()!=null && dati.getDataIngressoRichiesta()!=null){
  1481.                 latenza = dati.getDataUscitaRichiesta().getTime()-dati.getDataIngressoRichiesta().getTime();
  1482.             }
  1483.             if(dati.getDataIngressoRisposta()!=null && dati.getDataUscitaRisposta()!=null){
  1484.                 latenza = latenza + dati.getDataUscitaRisposta().getTime()-dati.getDataIngressoRisposta().getTime();
  1485.             }
  1486.             break;
  1487.         }
  1488.         return latenza;
  1489.     }
  1490.     
  1491.     protected long getBanda(TipoBanda tipoBanda, MisurazioniTransazione dati){
  1492.         
  1493.         long bandaInterna = 0;
  1494.         long bandaEsterna = 0;
  1495.         if(TipoPdD.DELEGATA.equals(dati.getTipoPdD())) {
  1496.             if(dati.getRichiestaIngressoBytes()!=null && dati.getRichiestaIngressoBytes()>0){
  1497.                 bandaInterna = bandaInterna + dati.getRichiestaIngressoBytes().longValue();
  1498.             }
  1499.             if(dati.getRispostaUscitaBytes()!=null && dati.getRispostaUscitaBytes()>0){
  1500.                 bandaInterna = bandaInterna + dati.getRispostaUscitaBytes().longValue();
  1501.             }
  1502.             
  1503.             if(dati.getRichiestaUscitaBytes()!=null && dati.getRichiestaUscitaBytes()>0){
  1504.                 bandaEsterna = bandaEsterna + dati.getRichiestaUscitaBytes().longValue();
  1505.             }
  1506.             if(dati.getRispostaIngressoBytes()!=null && dati.getRispostaIngressoBytes()>0){
  1507.                 bandaEsterna = bandaEsterna + dati.getRispostaIngressoBytes().longValue();
  1508.             }
  1509.         }else{
  1510.             if(dati.getRichiestaIngressoBytes()!=null && dati.getRichiestaIngressoBytes()>0){
  1511.                 bandaEsterna = bandaEsterna + dati.getRichiestaIngressoBytes().longValue();
  1512.             }
  1513.             if(dati.getRispostaUscitaBytes()!=null && dati.getRispostaUscitaBytes()>0){
  1514.                 bandaEsterna = bandaEsterna + dati.getRispostaUscitaBytes().longValue();
  1515.             }
  1516.             
  1517.             if(dati.getRichiestaUscitaBytes()!=null && dati.getRichiestaUscitaBytes()>0){
  1518.                 bandaInterna = bandaInterna + dati.getRichiestaUscitaBytes().longValue();
  1519.             }
  1520.             if(dati.getRispostaIngressoBytes()!=null && dati.getRispostaIngressoBytes()>0){
  1521.                 bandaInterna = bandaInterna + dati.getRispostaIngressoBytes().longValue();
  1522.             }
  1523.         }
  1524.         
  1525.         
  1526.         switch (tipoBanda) {
  1527.         case COMPLESSIVA:
  1528.             return bandaEsterna + bandaInterna;
  1529.         case INTERNA:
  1530.             return bandaInterna;
  1531.         case ESTERNA:
  1532.             return bandaEsterna;
  1533.         }
  1534.         return 0;
  1535.     }
  1536.     
  1537.     

  1539.     
  1540.     // ****** GETTER ******

  1542.     public Date getCloneDate() {
  1543.         return this.cloneDate;
  1544.     }
  1545.     
  1546.     public TipoRisorsa getTipoRisorsa() {
  1547.         return this.tipoRisorsa;
  1548.     }
  1549.     
  1550.     public Long getActiveRequestCounter() {
  1551.         return getActiveRequestCounter(false);
  1552.     }
  1553.     protected Long getActiveRequestCounter(boolean readRemoteInfo) {
  1554.         if(readRemoteInfo) {
  1555.             // nop
  1556.         }
  1557.         return this.activeRequestCounter;
  1558.     }
  1559.     public Date getCreationDate() {
  1560.         return this.creationDate;
  1561.     }
  1562.     public Date getUpdatePolicyDate() {
  1563.         return this.updatePolicyDate;
  1564.     }
  1565.     public Date getGestorePolicyConfigDate() {
  1566.         return this.gestorePolicyConfigDate;
  1567.     }
  1568.     
  1569.     @Deprecated
  1570.     public Long getManuallyResetPolicyTimeMillis() {
  1571.         return this.manuallyResetPolicyTimeMillis;
  1572.     }

  1574.     public Date getPolicyDate() {
  1575.         return this.policyDate;
  1576.     }   
  1577.     public Long getPolicyRequestCounter() {
  1578.         return getPolicyRequestCounter(false);
  1579.     }
  1580.     protected Long getPolicyRequestCounter(boolean readRemoteInfo) {
  1581.         if(readRemoteInfo) {
  1582.             // nop
  1583.         }
  1584.         return this.policyRequestCounter;
  1585.     }
  1586.     public Long getPolicyCounter() {
  1587.         return getPolicyCounter(false);
  1588.     }
  1589.     protected Long getPolicyCounter(boolean readRemoteInfo) {
  1590.         if(readRemoteInfo) {
  1591.             // nop
  1592.         }
  1593.         return this.policyCounter;
  1594.     }
  1595.     @Deprecated
  1596.     public Long getPolicyDenyRequestCounter() {
  1597.         return this.policyDenyRequestCounter;
  1598.     }
  1599.     @Deprecated
  1600.     public Long getPolicyDegradoPrestazionaleRequestCounter() {
  1601.         return this.policyDegradoPrestazionaleRequestCounter;
  1602.     }
  1603.     @Deprecated
  1604.     public Long getPolicyDegradoPrestazionaleCounter() {
  1605.         return this.policyDegradoPrestazionaleCounter;
  1606.     }
  1607.     public Double getPolicyAvgValue(){
  1608.         return getPolicyAvgValue(false);
  1609.     }
  1610.     protected Double getPolicyAvgValue(boolean readRemoteInfo){
  1611.         Double doubleValue = null;
  1612.         Long getPolicyCounter = getPolicyCounter(readRemoteInfo);
  1613.         Long getPolicyRequestCounter = getPolicyRequestCounter(readRemoteInfo);
  1614.         if(getPolicyCounter!=null && getPolicyRequestCounter!=null){
  1615.             double c = getPolicyCounter.doubleValue();
  1616.             double n = getPolicyRequestCounter.doubleValue();
  1617.             doubleValue = c/n;
  1618.         }
  1619.         return doubleValue;
  1620.     }
  1621.     protected Long getPolicyDenyRequestCounter(boolean readRemoteInfo) {
  1622.         if(readRemoteInfo) {
  1623.             // nop
  1624.         }
  1625.         return this.policyDenyRequestCounter;
  1626.     }
  1627.     public Date getLeftDateWindowCurrentInterval() {
  1628.         if(this.policyDate!=null && this.policyDateTypeInterval!=null){
  1629.             return DateUtils.convertToLeftInterval(this.policyDate, this.policyDateTypeInterval);
  1630.         }
  1631.         return null;
  1632.     }
  1633.     public Date getRightDateWindowCurrentInterval() {
  1634.         if(this.policyDate!=null && this.policyDateTypeInterval!=null && this.policyDateInterval!=null && this.policyDateCurrentInterval!=null){
  1635.             Date d = DateUtils.convertToRightInterval(this.policyDate, this.policyDateTypeInterval);
  1636.             return DatiCollezionati.incrementDate(d, this.policyDateTypeInterval, this.policyDateInterval, this.policyDateCurrentInterval);
  1637.         }
  1638.         return null;
  1639.     }   
  1640.     
  1641.     public Date getOldPolicyDate() {
  1642.         return this.oldPolicyDate;
  1643.     }
  1644.     public Long getOldPolicyRequestCounter() {
  1645.         return this.oldPolicyRequestCounter;
  1646.     }
  1647.     public Long getOldPolicyCounter() {
  1648.         return this.oldPolicyCounter;
  1649.     }
  1650.     public Double getOldPolicyAvgValue(){
  1651.         Double doubleValue = null;
  1652.         if(this.oldPolicyCounter!=null && this.oldPolicyRequestCounter!=null){
  1653.             double c = this.oldPolicyCounter.doubleValue();
  1654.             double n = this.oldPolicyRequestCounter.doubleValue();
  1655.             doubleValue = c/n;
  1656.         }
  1657.         return doubleValue;
  1658.     }
  1659.     public Date getLeftDateWindowPrecedentInterval() {
  1660.         if(this.oldPolicyDate!=null && this.policyDateTypeInterval!=null){
  1661.             return DateUtils.convertToLeftInterval(this.oldPolicyDate, this.policyDateTypeInterval);
  1662.         }
  1663.         return null;
  1664.     }
  1665.     public Date getRightDateWindowPrecedentInterval() {
  1666.         if(this.oldPolicyDate!=null && this.policyDateTypeInterval!=null && this.policyDateInterval!=null && this.policyDateCurrentInterval!=null){
  1667.             Date d = DateUtils.convertToRightInterval(this.oldPolicyDate, this.policyDateTypeInterval);
  1668.             return DatiCollezionati.incrementDate(d, this.policyDateTypeInterval, this.policyDateInterval, this.policyDateCurrentInterval);
  1669.         }
  1670.         return null;
  1671.     }   
  1672.         
  1673.     
  1674.     public Integer getPolicyDateInterval() {
  1675.         return this.policyDateInterval;
  1676.     }
  1677.     public Boolean getPolicyDateCurrentInterval() {
  1678.         return this.policyDateCurrentInterval;
  1679.     }
  1680.     public UnitaTemporale getPolicyDateTypeInterval() {
  1681.         return this.policyDateTypeInterval;
  1682.     }
  1683.     public TipoFinestra getPolicyDateWindowInterval() {
  1684.         return this.policyDateWindowInterval;
  1685.     }
  1686.     public Boolean getPolicyRealtime() {
  1687.         return this.policyRealtime;
  1688.     }
  1689.     
  1690.     public Date getLeftDateWindowSlidingInterval(Date now) {
  1691.         if(this.policyDateTypeInterval!=null && this.policyDateInterval!=null && this.policyDateCurrentInterval!=null){
  1692.             Date d = DateUtils.convertToLeftInterval(now, this.policyDateTypeInterval);
  1693.             return DatiCollezionati.decrementDate(d, this.policyDateTypeInterval, this.policyDateInterval, this.policyDateCurrentInterval);
  1694.         }
  1695.         return null;
  1696.     }
  1697.     public Date getRightDateWindowSlidingInterval(Date now) {
  1698.         if(this.policyDateTypeInterval!=null && this.policyDateCurrentInterval!=null){
  1699.             Date d = DateUtils.convertToRightInterval(now, this.policyDateTypeInterval);
  1700.             if(!this.policyDateCurrentInterval.booleanValue()){
  1701.                 d = DateUtils.incrementDate(d, this.policyDateTypeInterval, -1);
  1702.             }
  1703.             return d;
  1704.         }
  1705.         return null;
  1706.     }
  1707.     
  1708.         
  1709.     public Date getPolicyDegradoPrestazionaleDate() {
  1710.         return this.policyDegradoPrestazionaleDate;
  1711.     }
  1712.     protected Long getPolicyDegradoPrestazionaleRequestCounter(boolean readRemoteInfo) {
  1713.         if(readRemoteInfo) {
  1714.             // nop
  1715.         }
  1716.         return this.policyDegradoPrestazionaleRequestCounter;
  1717.     }
  1718.     protected Long getPolicyDegradoPrestazionaleCounter(boolean readRemoteInfo) {
  1719.         if(readRemoteInfo) {
  1720.             // nop
  1721.         }
  1722.         return this.policyDegradoPrestazionaleCounter;
  1723.     }
  1724.     public Double getPolicyDegradoPrestazionaleAvgValue(){
  1725.         return getPolicyDegradoPrestazionaleAvgValue(false);
  1726.     }
  1727.     protected Double getPolicyDegradoPrestazionaleAvgValue(boolean readRemoteInfo){
  1728.         Double doubleValue = null;
  1729.         Long getPolicyDegradoPrestazionaleRequestCounter = getPolicyDegradoPrestazionaleRequestCounter(readRemoteInfo);
  1730.         Long getPolicyDegradoPrestazionaleCounter = getPolicyDegradoPrestazionaleCounter(readRemoteInfo);
  1731.         if(getPolicyDegradoPrestazionaleCounter!=null && getPolicyDegradoPrestazionaleRequestCounter!=null){
  1732.             double c = getPolicyDegradoPrestazionaleCounter.doubleValue();
  1733.             double n = getPolicyDegradoPrestazionaleRequestCounter.doubleValue();
  1734.             doubleValue = c/n;
  1735.         }
  1736.         return doubleValue;
  1737.     }
  1738.     public Date getDegradoPrestazionaleLeftDateWindowCurrentInterval() {
  1739.         if(this.policyDegradoPrestazionaleDate!=null && this.policyDegradoPrestazionaleDateTypeInterval!=null){
  1740.             return DateUtils.convertToLeftInterval(this.policyDegradoPrestazionaleDate, this.policyDegradoPrestazionaleDateTypeInterval);
  1741.         }
  1742.         return null;
  1743.     }
  1744.     public Date getDegradoPrestazionaleRightDateWindowCurrentInterval() {
  1745.         if(this.policyDegradoPrestazionaleDate!=null && this.policyDegradoPrestazionaleDateTypeInterval!=null && 
  1746.                 this.policyDegradoPrestazionaleDateInterval!=null && this.policyDegradoPrestazionaleDateCurrentInterval!=null){
  1747.             Date d = DateUtils.convertToRightInterval(this.policyDegradoPrestazionaleDate, this.policyDegradoPrestazionaleDateTypeInterval);
  1748.             return DatiCollezionati.incrementDate(d, this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval, this.policyDegradoPrestazionaleDateCurrentInterval);
  1749.         }
  1750.         return null;
  1751.     }   
  1752.     public Date getOldPolicyDegradoPrestazionaleDate() {
  1753.         return this.oldPolicyDegradoPrestazionaleDate;
  1754.     }
  1755.     public Long getOldPolicyDegradoPrestazionaleRequestCounter() {
  1756.         return this.oldPolicyDegradoPrestazionaleRequestCounter;
  1757.     }
  1758.     public Long getOldPolicyDegradoPrestazionaleCounter() {
  1759.         return this.oldPolicyDegradoPrestazionaleCounter;
  1760.     }
  1761.     public Double getOldPolicyDegradoPrestazionaleAvgValue(){
  1762.         Double doubleValue = null;
  1763.         if(this.oldPolicyDegradoPrestazionaleCounter!=null && this.oldPolicyDegradoPrestazionaleRequestCounter!=null){
  1764.             double c = this.oldPolicyDegradoPrestazionaleCounter.doubleValue();
  1765.             double n = this.oldPolicyDegradoPrestazionaleRequestCounter.doubleValue();
  1766.             doubleValue = c/n;
  1767.         }
  1768.         return doubleValue;
  1769.     }
  1770.     public Date getDegradoPrestazionaleLeftDateWindowPrecedentInterval() {
  1771.         if(this.oldPolicyDegradoPrestazionaleDate!=null && this.policyDegradoPrestazionaleDateTypeInterval!=null){
  1772.             return DateUtils.convertToLeftInterval(this.oldPolicyDegradoPrestazionaleDate, this.policyDegradoPrestazionaleDateTypeInterval);
  1773.         }
  1774.         return null;
  1775.     }
  1776.     public Date getDegradoPrestazionaleRightDateWindowPrecedentInterval() {
  1777.         if(this.oldPolicyDegradoPrestazionaleDate!=null && this.policyDegradoPrestazionaleDateTypeInterval!=null && 
  1778.                 this.policyDegradoPrestazionaleDateInterval!=null && this.policyDegradoPrestazionaleDateCurrentInterval!=null){
  1779.             Date d = DateUtils.convertToRightInterval(this.oldPolicyDegradoPrestazionaleDate, this.policyDegradoPrestazionaleDateTypeInterval);
  1780.             return DatiCollezionati.incrementDate(d, this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval, this.policyDegradoPrestazionaleDateCurrentInterval);
  1781.         }
  1782.         return null;
  1783.     }
  1784.         
  1785.     public Integer getPolicyDegradoPrestazionaleDateInterval() {
  1786.         return this.policyDegradoPrestazionaleDateInterval;
  1787.     }
  1788.     public Boolean getPolicyDegradoPrestazionaleDateCurrentInterval() {
  1789.         return this.policyDegradoPrestazionaleDateCurrentInterval;
  1790.     }
  1791.     public UnitaTemporale getPolicyDegradoPrestazionaleDateTypeInterval() {
  1792.         return this.policyDegradoPrestazionaleDateTypeInterval;
  1793.     }
  1794.     public TipoFinestra getPolicyDegradoPrestazionaleDateWindowInterval() {
  1795.         return this.policyDegradoPrestazionaleDateWindowInterval;
  1796.     }
  1797.     public Boolean getPolicyDegradoPrestazionaleRealtime() {
  1798.         return this.policyDegradoPrestazionaleRealtime;
  1799.     }

  1801.     
  1802.     public Date getDegradoPrestazionaleLeftDateWindowSlidingInterval(Date now) {
  1803.         if(this.policyDegradoPrestazionaleDateTypeInterval!=null && this.policyDegradoPrestazionaleDateInterval!=null && this.policyDegradoPrestazionaleDateCurrentInterval!=null){
  1804.             Date d = DateUtils.convertToLeftInterval(now, this.policyDegradoPrestazionaleDateTypeInterval);
  1805.             return DatiCollezionati.decrementDate(d, this.policyDegradoPrestazionaleDateTypeInterval, this.policyDegradoPrestazionaleDateInterval, this.policyDegradoPrestazionaleDateCurrentInterval);
  1806.         }
  1807.         return null;
  1808.     }
  1809.     public Date getDegradoPrestazionaleRightDateWindowSlidingInterval(Date now) {
  1810.         if(this.policyDegradoPrestazionaleDateTypeInterval!=null && this.policyDegradoPrestazionaleDateCurrentInterval!=null){
  1811.             Date d = DateUtils.convertToRightInterval(now, this.policyDegradoPrestazionaleDateTypeInterval);
  1812.             if(!this.policyDegradoPrestazionaleDateCurrentInterval.booleanValue()){
  1813.                 d = DateUtils.incrementDate(d, this.policyDegradoPrestazionaleDateTypeInterval, -1);
  1814.             }
  1815.             return d;
  1816.         }
  1817.         return null;
  1818.     }
  1819.     
  1820.     

  1822.     
  1823.     
  1824.     // ****** SETTER DEPRECATI ******

  1826.     @Deprecated
  1827.     public void setTipoRisorsa(TipoRisorsa tipoRisorsa) {
  1828.         this.tipoRisorsa = tipoRisorsa;
  1829.     }

  1831.     public void initActiveRequestCounter() {
  1832.         this.activeRequestCounter = 0l;
  1833.     }
  1834.     @Deprecated
  1835.     public void setActiveRequestCounter(long activeRequestCounter) {
  1836.         this.activeRequestCounter = activeRequestCounter;
  1837.     }
  1838.     public long setAndGetActiveRequestCounter(long activeRequestCounter) {
  1839.         this.activeRequestCounter = activeRequestCounter;
  1840.         return this.activeRequestCounter;
  1841.     }
  1842.     @Deprecated
  1843.     public void setCreationDate(Date creationDate) {
  1844.         this.creationDate = creationDate;
  1845.     }
  1846.     @Deprecated
  1847.     public void setUpdatePolicyDate(Date updatePolicyDate) {
  1848.         this.updatePolicyDate = updatePolicyDate;
  1849.     }

  1851.     @Deprecated
  1852.     public void setPolicyDateInterval(Integer policyDateInterval) {
  1853.         this.policyDateInterval = policyDateInterval;
  1854.     }
  1855.     @Deprecated
  1856.     public void setPolicyDateCurrentInterval(Boolean policyDateCurrentInterval) {
  1857.         this.policyDateCurrentInterval = policyDateCurrentInterval;
  1858.     }
  1859.     @Deprecated
  1860.     public void setPolicyDateTypeInterval(UnitaTemporale policyDateTypeInterval) {
  1861.         this.policyDateTypeInterval = policyDateTypeInterval;
  1862.     }
  1863.     @Deprecated
  1864.     public void setPolicyDateWindowInterval(TipoFinestra policyDateWindowInterval) {
  1865.         this.policyDateWindowInterval = policyDateWindowInterval;
  1866.     }
  1867.     @Deprecated
  1868.     public void setPolicyRealtime(Boolean policyRealtime) {
  1869.         this.policyRealtime = policyRealtime;
  1870.     }
  1871.     @Deprecated
  1872.     public void setPolicyDate(Date policyDate) {
  1873.         this.policyDate = policyDate;
  1874.     }
  1875.     @Deprecated
  1876.     public void setPolicyRequestCounter(Long policyRequestCounter) {
  1877.         this.policyRequestCounter = policyRequestCounter;
  1878.     }
  1879.     public Long setAndGetPolicyRequestCounter(Long policyRequestCounter) {
  1880.         this.policyRequestCounter = policyRequestCounter;
  1881.         return this.policyRequestCounter;
  1882.     }
  1883.     @Deprecated
  1884.     public void setPolicyCounter(Long policyCounter) {
  1885.         this.policyCounter = policyCounter;
  1886.     }
  1887.     @Deprecated
  1888.     public void setPolicyDenyRequestCounter(Long policyDenyRequestCounter) {
  1889.         this.policyDenyRequestCounter = policyDenyRequestCounter;
  1890.     }
  1891.     
  1892.     @Deprecated
  1893.     public void setOldPolicyDate(Date oldPolicyDate) {
  1894.         this.oldPolicyDate = oldPolicyDate;
  1895.     }
  1896.     @Deprecated
  1897.     public void setOldPolicyRequestCounter(Long oldPolicyRequestCounter) {
  1898.         this.oldPolicyRequestCounter = oldPolicyRequestCounter;
  1899.     }
  1900.     @Deprecated
  1901.     public void setOldPolicyCounter(Long oldPolicyCounter) {
  1902.         this.oldPolicyCounter = oldPolicyCounter;
  1903.     }

  1905.     @Deprecated
  1906.     public void setPolicyDegradoPrestazionaleDateInterval(Integer policyDegradoPrestazionaleDateInterval) {
  1907.         this.policyDegradoPrestazionaleDateInterval = policyDegradoPrestazionaleDateInterval;
  1908.     }
  1909.     @Deprecated
  1910.     public void setPolicyDegradoPrestazionaleDateCurrentInterval(Boolean policyDegradoPrestazionaleDateCurrentInterval) {
  1911.         this.policyDegradoPrestazionaleDateCurrentInterval = policyDegradoPrestazionaleDateCurrentInterval;
  1912.     }
  1913.     @Deprecated
  1914.     public void setPolicyDegradoPrestazionaleDateTypeInterval(UnitaTemporale policyDegradoPrestazionaleDateTypeInterval) {
  1915.         this.policyDegradoPrestazionaleDateTypeInterval = policyDegradoPrestazionaleDateTypeInterval;
  1916.     }
  1917.     @Deprecated
  1918.     public void setPolicyDegradoPrestazionaleDateWindowInterval(TipoFinestra policyDegradoPrestazionaleDateWindowInterval) {
  1919.         this.policyDegradoPrestazionaleDateWindowInterval = policyDegradoPrestazionaleDateWindowInterval;
  1920.     }
  1921.     @Deprecated
  1922.     public void setPolicyDegradoPrestazionaleRealtime(Boolean policyDegradoPrestazionaleRealtime) {
  1923.         this.policyDegradoPrestazionaleRealtime = policyDegradoPrestazionaleRealtime;
  1924.     }
  1925.     
  1926.     @Deprecated
  1927.     public void setPolicyDegradoPrestazionaleDate(Date policyDegradoPrestazionaleDate) {
  1928.         this.policyDegradoPrestazionaleDate = policyDegradoPrestazionaleDate;
  1929.     }
  1930.     @Deprecated
  1931.     public void setPolicyDegradoPrestazionaleRequestCounter(Long policyDegradoPrestazionaleRequestCounter) {
  1932.         this.policyDegradoPrestazionaleRequestCounter = policyDegradoPrestazionaleRequestCounter;
  1933.     }
  1934.     @Deprecated
  1935.     public void setPolicyDegradoPrestazionaleCounter(Long policyDegradoPrestazionaleCounter) {
  1936.         this.policyDegradoPrestazionaleCounter = policyDegradoPrestazionaleCounter;
  1937.     }
  1938.     @Deprecated
  1939.     public void setOldPolicyDegradoPrestazionaleDate(Date oldPolicyDegradoPrestazionaleDate) {
  1940.         this.oldPolicyDegradoPrestazionaleDate = oldPolicyDegradoPrestazionaleDate;
  1941.     }
  1942.     @Deprecated
  1943.     public void setOldPolicyDegradoPrestazionaleRequestCounter(Long oldPolicyDegradoPrestazionaleRequestCounter) {
  1944.         this.oldPolicyDegradoPrestazionaleRequestCounter = oldPolicyDegradoPrestazionaleRequestCounter;
  1945.     }
  1946.     @Deprecated
  1947.     public void setOldPolicyDegradoPrestazionaleCounter(Long oldPolicyDegradoPrestazionaleCounter) {
  1948.         this.oldPolicyDegradoPrestazionaleCounter = oldPolicyDegradoPrestazionaleCounter;
  1949.     }


  1952.     



  1956.     
  1957.     // **** UTILITIES ****
  1958.         
  1959.     public static String serialize(DatiCollezionati dati){
  1960.         StringBuilder bf = new StringBuilder();
  1961.         
  1962.         // data di lettura delle informazioni
  1963.         if(dati.cloneDate!=null)
  1964.             bf.append(dati.cloneDate.getTime());
  1965.         else
  1966.             bf.append("-");
  1967.         bf.append("\n");
  1968.         
  1969.         
  1970.         // tipo di risorsa
  1971.         if(dati.tipoRisorsa!=null)
  1972.             bf.append(dati.tipoRisorsa.getValue());
  1973.         else
  1974.             bf.append("-");
  1975.         bf.append("\n");
  1976.         
  1977.         
  1978.         // threads
  1979.         Long getActiveRequestCounter = dati.getActiveRequestCounter(true);
  1980.         if(getActiveRequestCounter != null)
  1981.             bf.append(getActiveRequestCounter);
  1982.         else
  1983.             bf.append("-");
  1984.         bf.append("\n");
  1985.         
  1986.         
  1987.         // data di creazione
  1988.         if(dati.creationDate!=null)
  1989.             bf.append(dati.creationDate.getTime());
  1990.         else
  1991.             bf.append("-");
  1992.         bf.append("\n");
  1993.         
  1994.         
  1995.         // dati iniziali
  1996.         if(dati.policyDateTypeInterval!=null)
  1997.             bf.append(dati.policyDateTypeInterval.getValue());
  1998.         else
  1999.             bf.append("-");
  2000.         bf.append("\n");
  2001.         if(dati.policyDateInterval!=null)
  2002.             bf.append(dati.policyDateInterval);
  2003.         else
  2004.             bf.append("-");
  2005.         bf.append("\n");
  2006.         if(dati.policyDateCurrentInterval!=null)
  2007.             bf.append(dati.policyDateCurrentInterval);
  2008.         else
  2009.             bf.append("-");
  2010.         bf.append("\n");
  2011.         if(dati.policyDateWindowInterval!=null)
  2012.             bf.append(dati.policyDateWindowInterval.getValue());
  2013.         else
  2014.             bf.append("-");
  2015.         bf.append("\n");
  2016.         if(dati.policyRealtime!=null)
  2017.             bf.append(dati.policyRealtime);
  2018.         else
  2019.             bf.append("-");
  2020.         bf.append("\n");


  2023.         // dati dinamici
  2024.         if(dati.policyDate!=null)
  2025.             bf.append(dati.policyDate.getTime());
  2026.         else
  2027.             bf.append("-");
  2028.         bf.append("\n");
  2029.         Long getPolicyRequestCounter = dati.getPolicyRequestCounter(true);
  2030.         if(getPolicyRequestCounter!=null)
  2031.             bf.append(getPolicyRequestCounter);
  2032.         else
  2033.             bf.append("-");
  2034.         bf.append("\n");
  2035.         Long getPolicyCounter = dati.getPolicyCounter(true);
  2036.         if(getPolicyCounter!=null)
  2037.             bf.append(getPolicyCounter);
  2038.         else
  2039.             bf.append("-");
  2040.         bf.append("\n");
  2041.         Long getPolicyDenyRequestCounter = dati.getPolicyDenyRequestCounter(true);
  2042.         if(getPolicyDenyRequestCounter!=null)
  2043.             bf.append(getPolicyDenyRequestCounter);
  2044.         else
  2045.             bf.append("-");
  2046.         bf.append("\n");
  2047.         if(dati.oldPolicyDate!=null)
  2048.             bf.append(dati.oldPolicyDate.getTime());
  2049.         else
  2050.             bf.append("-");
  2051.         bf.append("\n");
  2052.         if(dati.oldPolicyRequestCounter!=null)
  2053.             bf.append(dati.oldPolicyRequestCounter);
  2054.         else
  2055.             bf.append("-");
  2056.         bf.append("\n");
  2057.         if(dati.oldPolicyCounter!=null)
  2058.             bf.append(dati.oldPolicyCounter);
  2059.         else
  2060.             bf.append("-");
  2061.         bf.append("\n");

  2063.         
  2064.         // dati iniziali degrado prestazionale
  2065.         if(dati.policyDegradoPrestazionaleDateTypeInterval!=null)
  2066.             bf.append(dati.policyDegradoPrestazionaleDateTypeInterval.getValue());
  2067.         else
  2068.             bf.append("-");
  2069.         bf.append("\n");
  2070.         if(dati.policyDegradoPrestazionaleDateInterval!=null)
  2071.             bf.append(dati.policyDegradoPrestazionaleDateInterval);
  2072.         else
  2073.             bf.append("-");
  2074.         bf.append("\n");
  2075.         if(dati.policyDegradoPrestazionaleDateCurrentInterval!=null)
  2076.             bf.append(dati.policyDegradoPrestazionaleDateCurrentInterval);
  2077.         else
  2078.             bf.append("-");
  2079.         bf.append("\n");
  2080.         if(dati.policyDegradoPrestazionaleDateWindowInterval!=null)
  2081.             bf.append(dati.policyDegradoPrestazionaleDateWindowInterval.getValue());
  2082.         else
  2083.             bf.append("-");
  2084.         bf.append("\n");
  2085.         if(dati.policyDegradoPrestazionaleRealtime!=null)
  2086.             bf.append(dati.policyDegradoPrestazionaleRealtime);
  2087.         else
  2088.             bf.append("-");
  2089.         bf.append("\n");


  2092.         // dati dinamici degrado prestazionale
  2093.         if(dati.policyDegradoPrestazionaleDate!=null)
  2094.             bf.append(dati.policyDegradoPrestazionaleDate.getTime());
  2095.         else
  2096.             bf.append("-");
  2097.         bf.append("\n");
  2098.         Long getPolicyDegradoPrestazionaleRequestCounter = dati.getPolicyDegradoPrestazionaleRequestCounter(true);
  2099.         if(getPolicyDegradoPrestazionaleRequestCounter!=null)
  2100.             bf.append(getPolicyDegradoPrestazionaleRequestCounter);
  2101.         else
  2102.             bf.append("-");
  2103.         bf.append("\n");
  2104.         Long getPolicyDegradoPrestazionaleCounter = dati.getPolicyDegradoPrestazionaleCounter(true);
  2105.         if(getPolicyDegradoPrestazionaleCounter!=null)
  2106.             bf.append(getPolicyDegradoPrestazionaleCounter);
  2107.         else
  2108.             bf.append("-");
  2109.         bf.append("\n");
  2110.         if(dati.oldPolicyDegradoPrestazionaleDate!=null)
  2111.             bf.append(dati.oldPolicyDegradoPrestazionaleDate.getTime());
  2112.         else
  2113.             bf.append("-");
  2114.         bf.append("\n");
  2115.         if(dati.oldPolicyDegradoPrestazionaleRequestCounter!=null)
  2116.             bf.append(dati.oldPolicyDegradoPrestazionaleRequestCounter);
  2117.         else
  2118.             bf.append("-");
  2119.         bf.append("\n");
  2120.         if(dati.oldPolicyDegradoPrestazionaleCounter!=null)
  2121.             bf.append(dati.oldPolicyDegradoPrestazionaleCounter);
  2122.         else
  2123.             bf.append("-");

  2125.         
  2126.         // data di registrazione/aggiornamento policy
  2127.         bf.append("\n");
  2128.         if(dati.updatePolicyDate!=null)
  2129.             bf.append(dati.updatePolicyDate.getTime());
  2130.         else
  2131.             bf.append("-");
  2132.         
  2133.         // data di configurazione gestore policy
  2134.         bf.append("\n");
  2135.         if(dati.gestorePolicyConfigDate!=null)
  2136.             bf.append(dati.gestorePolicyConfigDate.getTime());
  2137.         else
  2138.             bf.append("-");
  2139.         
  2140.         
  2141.         return bf.toString();
  2142.     }
  2143.     
  2144.     public static DatiCollezionati deserialize(String s) throws CoreException{
  2145.         DatiCollezionati dati = new DatiCollezionati(null, null);
  2146.         String [] tmp = s.split("\n");
  2147.         if(tmp==null){
  2148.             throw new CoreException("Wrong Format");
  2149.         }
  2150.         int oldLength = 27;
  2151.         int dataPolicyLength = oldLength +1;
  2152.         int dataConfigPolicyLength = dataPolicyLength +1;
  2153.         if(tmp.length!=oldLength && tmp.length!=dataPolicyLength && tmp.length!=dataConfigPolicyLength){
  2154.             throw new CoreException("Wrong Format (size: "+tmp.length+")");
  2155.         }
  2156.         for (int i = 0; i < tmp.length; i++) {
  2157.             
  2158.             // data di lettura delle informazioni
  2159.             if(i==0){
  2160.                 String tmpValue = tmp[i].trim();
  2161.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2162.                     dati.cloneDate = new Date(Long.parseLong(tmpValue));
  2163.                 }
  2164.             }
  2165.             
  2166.             // tipo di risorsa
  2167.             else if(i==1){
  2168.                 String tmpValue = tmp[i].trim();
  2169.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2170.                     dati.tipoRisorsa = TipoRisorsa.toEnumConstant(tmpValue);
  2171.                 }
  2172.             }
  2173.             
  2174.             // threads
  2175.             else if(i==2){
  2176.                 String tmpValue = tmp[i].trim();
  2177.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2178.                     dati.activeRequestCounter = Long.parseLong(tmpValue);
  2179.                 }
  2180.             }
  2181.             
  2182.             // data di creazione
  2183.             else if(i==3){
  2184.                 String tmpValue = tmp[i].trim();
  2185.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2186.                     dati.creationDate = new Date(Long.parseLong(tmpValue));
  2187.                 }
  2188.             }
  2189.             
  2190.             
  2191.             // dati iniziali
  2192.             else if(i==4){
  2193.                 String tmpValue = tmp[i].trim();
  2194.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2195.                     dati.policyDateTypeInterval = UnitaTemporale.toEnumConstant(tmpValue);
  2196.                 }
  2197.             }
  2198.             else if(i==5){
  2199.                 String tmpValue = tmp[i].trim();
  2200.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2201.                     dati.policyDateInterval = Integer.parseInt(tmpValue);
  2202.                 }
  2203.             }
  2204.             else if(i==6){
  2205.                 String tmpValue = tmp[i].trim();
  2206.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2207.                     dati.policyDateCurrentInterval = Boolean.parseBoolean(tmpValue);
  2208.                 }
  2209.             }
  2210.             else if(i==7){
  2211.                 String tmpValue = tmp[i].trim();
  2212.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2213.                     dati.policyDateWindowInterval = TipoFinestra.toEnumConstant(tmpValue);
  2214.                 }
  2215.             }
  2216.             else if(i==8){
  2217.                 String tmpValue = tmp[i].trim();
  2218.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2219.                     dati.policyRealtime = Boolean.parseBoolean(tmpValue);
  2220.                 }
  2221.             }
  2222.             
  2223.             // dati dinamici
  2224.             else if(i==9){
  2225.                 String tmpValue = tmp[i].trim();
  2226.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2227.                     dati.policyDate = new Date(Long.parseLong(tmpValue));
  2228.                 }
  2229.             }
  2230.             else if(i==10){
  2231.                 String tmpValue = tmp[i].trim();
  2232.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2233.                     dati.policyRequestCounter = Long.parseLong(tmpValue);
  2234.                 }
  2235.             }
  2236.             else if(i==11){
  2237.                 String tmpValue = tmp[i].trim();
  2238.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2239.                     dati.policyCounter = Long.parseLong(tmpValue);
  2240.                 }
  2241.             }
  2242.             else if(i==12){
  2243.                 String tmpValue = tmp[i].trim();
  2244.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2245.                     dati.policyDenyRequestCounter = Long.parseLong(tmpValue);
  2246.                 }
  2247.             }
  2248.             else if(i==13){
  2249.                 String tmpValue = tmp[i].trim();
  2250.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2251.                     dati.oldPolicyDate = new Date(Long.parseLong(tmpValue));
  2252.                 }
  2253.             }
  2254.             else if(i==14){
  2255.                 String tmpValue = tmp[i].trim();
  2256.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2257.                     dati.oldPolicyRequestCounter = Long.parseLong(tmpValue);
  2258.                 }
  2259.             }
  2260.             else if(i==15){
  2261.                 String tmpValue = tmp[i].trim();
  2262.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2263.                     dati.oldPolicyCounter = Long.parseLong(tmpValue);
  2264.                 }
  2265.             }
  2266.             
  2267.             // dati iniziali degrado prestazionale
  2268.             else if(i==16){
  2269.                 String tmpValue = tmp[i].trim();
  2270.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2271.                     dati.policyDegradoPrestazionaleDateTypeInterval = UnitaTemporale.toEnumConstant(tmpValue);
  2272.                 }
  2273.             }
  2274.             else if(i==17){
  2275.                 String tmpValue = tmp[i].trim();
  2276.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2277.                     dati.policyDegradoPrestazionaleDateInterval = Integer.parseInt(tmpValue);
  2278.                 }
  2279.             }
  2280.             else if(i==18){
  2281.                 String tmpValue = tmp[i].trim();
  2282.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2283.                     dati.policyDegradoPrestazionaleDateCurrentInterval = Boolean.parseBoolean(tmpValue);
  2284.                 }
  2285.             }
  2286.             else if(i==19){
  2287.                 String tmpValue = tmp[i].trim();
  2288.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2289.                     dati.policyDegradoPrestazionaleDateWindowInterval = TipoFinestra.toEnumConstant(tmpValue);
  2290.                 }
  2291.             }
  2292.             else if(i==20){
  2293.                 String tmpValue = tmp[i].trim();
  2294.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2295.                     dati.policyDegradoPrestazionaleRealtime = Boolean.parseBoolean(tmpValue);
  2296.                 }
  2297.             }
  2298.             
  2299.             // dati dinamici degrado prestazionale
  2300.             else if(i==21){
  2301.                 String tmpValue = tmp[i].trim();
  2302.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2303.                     dati.policyDegradoPrestazionaleDate = new Date(Long.parseLong(tmpValue));
  2304.                 }
  2305.             }
  2306.             else if(i==22){
  2307.                 String tmpValue = tmp[i].trim();
  2308.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2309.                     dati.policyDegradoPrestazionaleRequestCounter = Long.parseLong(tmpValue);
  2310.                 }
  2311.             }
  2312.             else if(i==23){
  2313.                 String tmpValue = tmp[i].trim();
  2314.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2315.                     dati.policyDegradoPrestazionaleCounter = Long.parseLong(tmpValue);
  2316.                 }
  2317.             }
  2318.             else if(i==24){
  2319.                 String tmpValue = tmp[i].trim();
  2320.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2321.                     dati.oldPolicyDegradoPrestazionaleDate = new Date(Long.parseLong(tmpValue));
  2322.                 }
  2323.             }
  2324.             else if(i==25){
  2325.                 String tmpValue = tmp[i].trim();
  2326.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2327.                     dati.oldPolicyDegradoPrestazionaleRequestCounter = Long.parseLong(tmpValue);
  2328.                 }
  2329.             }
  2330.             else if(i==26){
  2331.                 String tmpValue = tmp[i].trim();
  2332.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2333.                     dati.oldPolicyDegradoPrestazionaleCounter = Long.parseLong(tmpValue);
  2334.                 }
  2335.             }
  2336.             
  2337.             // data di registrazione/aggiornamento policy
  2338.             else if(i==27){
  2339.                 String tmpValue = tmp[i].trim();
  2340.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2341.                     dati.updatePolicyDate = new Date(Long.parseLong(tmpValue));
  2342.                 }
  2343.             }
  2344.             
  2345.             // data di configurazione gestore policy
  2346.             else if(i==28){
  2347.                 String tmpValue = tmp[i].trim();
  2348.                 if(tmpValue!=null && !"-".equals(tmpValue)){
  2349.                     dati.gestorePolicyConfigDate = new Date(Long.parseLong(tmpValue));
  2350.                 }
  2351.             }
  2352.         }
  2353.         
  2354.         if(dati.updatePolicyDate==null) {
  2355.             dati.updatePolicyDate = dati.creationDate; // per backward compatibility
  2356.         }
  2357.         
  2358.         return dati;
  2359.     }
  2360.     
  2361.     public static Long translateToKb(long counter) {
  2362.         return counter / 1024;
  2363.     }
  2364.     public static Long translateToSeconds(long counter) {
  2365.         return counter / 1000;
  2366.     }
  2367.     
  2368.     private static Date incrementDate(Date date,UnitaTemporale unitaTemporale,
  2369.             int intervallo, boolean consideraIntervalloAttuale) {
  2370.         
  2371.         int increment = 0;
  2372.         if(consideraIntervalloAttuale){
  2373.             if(intervallo>1){ // il fatto di riportare tutto allo ...59.999 vale già un intervallo se si deve considerare l'intervallo attuale.
  2374.                 increment = (intervallo-1);
  2375.             }
  2376.         }
  2377.         else{
  2378.             increment = intervallo;
  2379.         }
  2380.         
  2381.         return DateUtils.incrementDate(date, unitaTemporale, increment);
  2382.     }
  2383.     
  2384.     private static Date decrementDate(Date date, UnitaTemporale unitaTemporale,
  2385.             int intervallo, boolean consideraIntervalloAttuale) {
  2386.         
  2387.         int increment = 0;
  2388.         if(consideraIntervalloAttuale){
  2389.             if(intervallo>1){ // il fatto di riportare tutto allo ...59.999 vale già un intervallo se si deve considerare l'intervallo attuale.
  2390.                 increment = (intervallo-1);
  2391.             }
  2392.         }
  2393.         else{
  2394.             increment = intervallo;
  2395.         }
  2396.         if(increment!=0){
  2397.             increment = increment * (-1);
  2398.         }
  2399.         
  2400.         return DateUtils.incrementDate(date, unitaTemporale, increment);
  2401.     }
  2402. }
Created with JaCoCo 0.8.8.202204050719