GestoreHandlers.java

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


  22. package org.openspcoop2.pdd.core.handlers;

  24. import java.util.ArrayList;
  25. import java.util.Collections;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;

  30. import org.openspcoop2.core.config.PortaApplicativa;
  31. import org.openspcoop2.core.config.PortaDelegata;
  32. import org.openspcoop2.core.constants.TipoPdD;
  33. import org.openspcoop2.core.id.IDPortaApplicativa;
  34. import org.openspcoop2.core.id.IDPortaDelegata;
  35. import org.openspcoop2.pdd.config.ClassNameProperties;
  36. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  37. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  38. import org.openspcoop2.pdd.config.dynamic.PddPluginLoader;
  39. import org.openspcoop2.pdd.core.PdDContext;
  40. import org.openspcoop2.pdd.core.handlers.notifier.NotifierConstants;
  41. import org.openspcoop2.pdd.core.handlers.notifier.NotifierInRequestHandler;
  42. import org.openspcoop2.pdd.core.handlers.notifier.NotifierInRequestProtocolHandler;
  43. import org.openspcoop2.pdd.core.handlers.notifier.NotifierInResponseHandler;
  44. import org.openspcoop2.pdd.core.handlers.notifier.NotifierOutRequestHandler;
  45. import org.openspcoop2.pdd.core.handlers.notifier.NotifierOutResponseHandler;
  46. import org.openspcoop2.pdd.core.handlers.notifier.NotifierPostOutRequestHandler;
  47. import org.openspcoop2.pdd.core.handlers.notifier.NotifierPostOutResponseHandler;
  48. import org.openspcoop2.pdd.core.handlers.notifier.NotifierPreInRequestHandler;
  49. import org.openspcoop2.pdd.core.handlers.notifier.NotifierPreInResponseHandler;
  50. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  51. import org.openspcoop2.protocol.sdk.state.IState;
  52. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  53. import org.openspcoop2.utils.date.DateManager;
  54. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  55. import org.openspcoop2.utils.resources.Loader;
  56. import org.slf4j.Logger;


  59. /**
  60.  * Utility per la registrazione delle informazioni di attraversamento della richiesta/risposta nella porta di dominio
  61.  *
  62.  * @author Poli Andrea (apoli@link.it)
  63.  * @author $Author$
  64.  * @version $Rev$, $Date$
  65.  */
  66. public class GestoreHandlers  {

  68.     private static boolean initialize = false;
  69.     private static OpenSPCoop2Properties properties = null;
  70.     private static GeneratoreCasualeDate generatoreCasualeDati = null;
  71.     
  72.     // Handlers BuiltIn
  73.     
  74.     private static InitHandler [] initHandlersBuiltIn = null;
  75.     private static String [] tipiInitHandlersBuiltIn = null;
  76.     
  77.     private static ExitHandler [] exitHandlersBuiltIn = null;
  78.     private static String [] tipiExitHandlersBuiltIn = null;
  79.     
  80.     private static PreInRequestHandler [] preInRequestHandlersBuiltIn = null;
  81.     private static String [] tipiPreInRequestHandlersBuiltIn = null;
  82.     
  83.     private static InRequestHandler [] inRequestHandlersBuiltIn = null;
  84.     private static String [] tipiInRequestHandlersBuiltIn = null;
  85.     
  86.     private static InRequestProtocolHandler [] inRequestProtocolHandlersBuiltIn = null;
  87.     private static String [] tipiInRequestProtocolHandlersBuiltIn = null;
  88.     
  89.     private static OutRequestHandler [] outRequestHandlersBuiltIn = null;
  90.     private static String [] tipiOutRequestHandlersBuiltIn = null;
  91.     
  92.     private static PostOutRequestHandler [] postOutRequestHandlersBuiltIn = null;
  93.     private static String [] tipiPostOutRequestHandlersBuiltIn = null;
  94.     
  95.     private static PreInResponseHandler [] preInResponseHandlersBuiltIn = null;
  96.     private static String [] tipiPreInResponseHandlersBuiltIn = null;
  97.     
  98.     private static InResponseHandler [] inResponseHandlersBuiltIn = null;
  99.     private static String [] tipiInResponseHandlersBuiltIn = null;
  100.     
  101.     private static OutResponseHandler [] outResponseHandlersBuiltIn = null;
  102.     private static String [] tipiOutResponseHandlersBuiltIn = null;
  103.     
  104.     private static PostOutResponseHandler [] postOutResponseHandlersBuiltIn = null;
  105.     private static String [] tipiPostOutResponseHandlersBuiltIn = null;
  106.     
  107.     private static IntegrationManagerRequestHandler [] integrationManagerRequestHandlersBuiltIn = null;
  108.     private static String [] tipiIntegrationManagerRequestHandlersBuiltIn = null;
  109.     
  110.     private static IntegrationManagerResponseHandler [] integrationManagerResponseHandlersBuiltIn = null;
  111.     private static String [] tipiIntegrationManagerResponseHandlersBuiltIn = null;
  112.     
  113.     // Handlers Utente
  114.     
  115.     private static InitHandler [] initHandlers = null;
  116.     private static String [] tipiInitHandlers = null;
  117.     
  118.     private static ExitHandler [] exitHandlers = null;
  119.     private static String [] tipiExitHandlers = null;
  120.     
  121.     private static PreInRequestHandler [] preInRequestHandlers = null;
  122.     private static String [] tipiPreInRequestHandlers = null;
  123.     
  124.     private static InRequestHandler [] inRequestHandlers = null;
  125.     private static String [] tipiInRequestHandlers = null;
  126.     
  127.     private static InRequestProtocolHandler [] inRequestProtocolHandlers = null;
  128.     private static String [] tipiInRequestProtocolHandlers = null;
  129.     
  130.     private static OutRequestHandler [] outRequestHandlers = null;
  131.     private static String [] tipiOutRequestHandlers = null;
  132.     
  133.     private static PostOutRequestHandler [] postOutRequestHandlers = null;
  134.     private static String [] tipiPostOutRequestHandlers = null;
  135.     
  136.     private static PreInResponseHandler [] preInResponseHandlers = null;
  137.     private static String [] tipiPreInResponseHandlers = null;
  138.     
  139.     private static InResponseHandler [] inResponseHandlers = null;
  140.     private static String [] tipiInResponseHandlers = null;
  141.     
  142.     private static OutResponseHandler [] outResponseHandlers = null;
  143.     private static String [] tipiOutResponseHandlers = null;
  144.     
  145.     private static PostOutResponseHandler [] postOutResponseHandlers = null;
  146.     private static String [] tipiPostOutResponseHandlers = null;
  147.     
  148.     private static IntegrationManagerRequestHandler [] integrationManagerRequestHandlers = null;
  149.     private static String [] tipiIntegrationManagerRequestHandlers = null;
  150.     
  151.     private static IntegrationManagerResponseHandler [] integrationManagerResponseHandlers = null;
  152.     private static String [] tipiIntegrationManagerResponseHandlers = null;

  154.     private static String [] toStringArray(Object [] tipiHandlersO) {
  155.         List<String> h = new ArrayList<>();
  156.         if(tipiHandlersO!=null && tipiHandlersO.length>0) {
  157.             for (Object o : tipiHandlersO) {
  158.                 if(o instanceof String) {
  159.                     h.add((String)o);
  160.                 }
  161.             }
  162.         }
  163.         if(!h.isEmpty()) {
  164.             return h.toArray(new String[1]);
  165.         }
  166.         return null;
  167.     }
  168.     
  169.     
  170.     private static void initialize(MsgDiagnostico msgDiag,Logger logConsoleInit,IState state){
  171.         initialize(msgDiag,null,logConsoleInit, state);
  172.     }
  173.     private static void initialize(Logger logCore,Logger logConsoleInit){
  174.         initialize(null,logCore,logConsoleInit, null);
  175.     }
  176.     private static synchronized void initialize(MsgDiagnostico msgDiag,Logger logCore, Logger logConsoleInit,IState state){
  177.         if(!GestoreHandlers.initialize){
  178.             
  179.             GestoreHandlers.properties = OpenSPCoop2Properties.getInstance();
  180.             ClassNameProperties classNameProperties = ClassNameProperties.getInstance();
  181.             Loader loader = Loader.getInstance();
  182.             PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  183.             if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && !UniqueIdentifierManager.isGenerazioneUIDDisabilitata()){
  184.                 GestoreHandlers.generatoreCasualeDati = GeneratoreCasualeDate.getGeneratoreCasualeDate();
  185.             }
  186.         
  187.             
  188.             // Handlers BuiltIn
  189.             
  190.             boolean printInfoBuiltIn = GestoreHandlers.properties.isPrintInfoHandlerBuiltIn();
  191.             
  192.             // InitHandler
  193.             GestoreHandlers.tipiInitHandlersBuiltIn = GestoreHandlers.properties.getInitHandlerBuiltIn();
  194.             if(GestoreHandlers.tipiInitHandlersBuiltIn!=null){
  195.                 GestoreHandlers.initHandlersBuiltIn = new InitHandler[GestoreHandlers.tipiInitHandlersBuiltIn.length];
  196.                 for(int i=0; i<GestoreHandlers.tipiInitHandlersBuiltIn.length; i++){
  197.                     try{
  198.                         String tipo=GestoreHandlers.tipiInitHandlersBuiltIn[i];
  199.                         String classe = classNameProperties.getInitHandlerBuiltIn(tipo);
  200.                         GestoreHandlers.initHandlersBuiltIn[i] = (InitHandler) loader.newInstance(classe);
  201.                         if(printInfoBuiltIn)
  202.                             logConsoleInit.info("InitHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  203.                     }catch(Throwable e){
  204.                         if(msgDiag!=null) {
  205.                             msgDiag.logErroreGenerico(e, "Inizializzazione InitHandler BuiltIn ["+GestoreHandlers.tipiInitHandlersBuiltIn[i]+"]");
  206.                         }
  207.                         else if(logCore!=null) {
  208.                             logCore.error("Inizializzazione InitHandler BuiltIn ["+GestoreHandlers.tipiInitHandlersBuiltIn[i]+"]", e);
  209.                         }
  210.                     }
  211.                 }
  212.                 GestoreHandlers.initHandlersBuiltIn = reorder(GestoreHandlers.initHandlersBuiltIn, new InitHandler[1]);
  213.             }
  214.             
  215.             // ExitHandler
  216.             GestoreHandlers.tipiExitHandlersBuiltIn = GestoreHandlers.properties.getExitHandlerBuiltIn();
  217.             if(GestoreHandlers.tipiExitHandlersBuiltIn!=null){
  218.                 GestoreHandlers.exitHandlersBuiltIn = new ExitHandler[GestoreHandlers.tipiExitHandlersBuiltIn.length];
  219.                 for(int i=0; i<GestoreHandlers.tipiExitHandlersBuiltIn.length; i++){
  220.                     try{
  221.                         String tipo=GestoreHandlers.tipiExitHandlersBuiltIn[i];
  222.                         String classe = classNameProperties.getExitHandlerBuiltIn(tipo);
  223.                         GestoreHandlers.exitHandlersBuiltIn[i] = (ExitHandler) loader.newInstance(classe);
  224.                         if(printInfoBuiltIn)
  225.                             logConsoleInit.info("ExitHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  226.                     }catch(Throwable e){
  227.                         if(msgDiag!=null) {
  228.                             msgDiag.logErroreGenerico(e, "Inizializzazione ExitHandler BuiltIn ["+GestoreHandlers.tipiExitHandlersBuiltIn[i]+"]");
  229.                         }
  230.                         else if(logCore!=null) {
  231.                             logCore.error("Inizializzazione ExitHandler BuiltIn ["+GestoreHandlers.tipiExitHandlersBuiltIn[i]+"]", e);
  232.                         }
  233.                     }
  234.                 }
  235.                 GestoreHandlers.exitHandlersBuiltIn = reorder(GestoreHandlers.exitHandlersBuiltIn, new ExitHandler[1]);
  236.             }
  237.             
  238.             // PreInRequestHandler
  239.             GestoreHandlers.tipiPreInRequestHandlersBuiltIn = GestoreHandlers.properties.getPreInRequestHandlerBuiltIn();
  240.             GestoreHandlers.tipiPreInRequestHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiPreInRequestHandlersBuiltIn);
  241.             if(GestoreHandlers.tipiPreInRequestHandlersBuiltIn!=null){
  242.                 GestoreHandlers.preInRequestHandlersBuiltIn = new PreInRequestHandler[GestoreHandlers.tipiPreInRequestHandlersBuiltIn.length];
  243.                 for(int i=0; i<GestoreHandlers.tipiPreInRequestHandlersBuiltIn.length; i++){
  244.                     try{
  245.                         String tipo=GestoreHandlers.tipiPreInRequestHandlersBuiltIn[i];
  246.                         String classe = null;
  247.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  248.                             classe = NotifierPreInRequestHandler.class.getName();
  249.                         }else{
  250.                             classe = classNameProperties.getPreInRequestHandlerBuiltIn(tipo);
  251.                         }
  252.                         GestoreHandlers.preInRequestHandlersBuiltIn[i] = (PreInRequestHandler) loader.newInstance(classe);
  253.                         if(printInfoBuiltIn)
  254.                             logConsoleInit.info("PreInRequestHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  255.                     }catch(Throwable e){
  256.                         if(msgDiag!=null) {
  257.                             msgDiag.logErroreGenerico(e, "Inizializzazione PreInRequestHandler BuiltIn ["+GestoreHandlers.tipiPreInRequestHandlersBuiltIn[i]+"]");
  258.                         }
  259.                         else if(logCore!=null) {
  260.                             logCore.error("Inizializzazione PreInRequestHandler BuiltIn ["+GestoreHandlers.tipiPreInRequestHandlersBuiltIn[i]+"]", e);
  261.                         }
  262.                     }
  263.                 }
  264.                 GestoreHandlers.preInRequestHandlersBuiltIn = reorder(GestoreHandlers.preInRequestHandlersBuiltIn, new PreInRequestHandler[1]);
  265.             }
  266.             
  267.             // InRequestHandler
  268.             GestoreHandlers.tipiInRequestHandlersBuiltIn = GestoreHandlers.properties.getInRequestHandlerBuiltIn();
  269.             GestoreHandlers.tipiInRequestHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiInRequestHandlersBuiltIn);
  270.             if(GestoreHandlers.tipiInRequestHandlersBuiltIn!=null){
  271.                 GestoreHandlers.inRequestHandlersBuiltIn = new InRequestHandler[GestoreHandlers.tipiInRequestHandlersBuiltIn.length];
  272.                 for(int i=0; i<GestoreHandlers.tipiInRequestHandlersBuiltIn.length; i++){
  273.                     try{
  274.                         String tipo=GestoreHandlers.tipiInRequestHandlersBuiltIn[i];
  275.                         String classe = null;
  276.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  277.                             classe = NotifierInRequestHandler.class.getName();
  278.                         }else{
  279.                             classe = classNameProperties.getInRequestHandlerBuiltIn(tipo);
  280.                         }
  281.                         GestoreHandlers.inRequestHandlersBuiltIn[i] = (InRequestHandler) loader.newInstance(classe);
  282.                         if(printInfoBuiltIn)
  283.                             logConsoleInit.info("InRequestHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  284.                     }catch(Throwable e){
  285.                         if(msgDiag!=null) {
  286.                             msgDiag.logErroreGenerico(e, "Inizializzazione InRequestHandler BuiltIn ["+GestoreHandlers.tipiInRequestHandlersBuiltIn[i]+"]");
  287.                         }
  288.                         else if(logCore!=null) {
  289.                             logCore.error("Inizializzazione InRequestHandler BuiltIn ["+GestoreHandlers.tipiInRequestHandlersBuiltIn[i]+"]", e);
  290.                         }
  291.                     }
  292.                 }
  293.                 GestoreHandlers.inRequestHandlersBuiltIn = reorder(GestoreHandlers.inRequestHandlersBuiltIn, new InRequestHandler[1]);
  294.             }
  295.             
  296.             // InRequestProtocolHandler
  297.             GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn = GestoreHandlers.properties.getInRequestProtocolHandlerBuiltIn();
  298.             GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn);
  299.             if(GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn!=null){
  300.                 GestoreHandlers.inRequestProtocolHandlersBuiltIn = new InRequestProtocolHandler[GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn.length];
  301.                 for(int i=0; i<GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn.length; i++){
  302.                     try{
  303.                         String tipo=GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn[i];
  304.                         String classe = null;
  305.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  306.                             classe = NotifierInRequestProtocolHandler.class.getName();
  307.                         }else{
  308.                             classe = classNameProperties.getInRequestProtocolHandlerBuiltIn(tipo);
  309.                         }
  310.                         GestoreHandlers.inRequestProtocolHandlersBuiltIn[i] = (InRequestProtocolHandler) loader.newInstance(classe);
  311.                         if(printInfoBuiltIn)
  312.                             logConsoleInit.info("InRequestProtocolHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  313.                     }catch(Throwable e){
  314.                         if(msgDiag!=null) {
  315.                             msgDiag.logErroreGenerico(e, "Inizializzazione InRequestProtocolHandler BuiltIn ["+GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn[i]+"]");
  316.                         }
  317.                         else if(logCore!=null) {
  318.                             logCore.error("Inizializzazione InRequestProtocolHandler BuiltIn ["+GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn[i]+"]", e);
  319.                         }
  320.                     }
  321.                 }
  322.                 GestoreHandlers.inRequestProtocolHandlersBuiltIn = reorder(GestoreHandlers.inRequestProtocolHandlersBuiltIn, new InRequestProtocolHandler[1]);
  323.             }
  324.             
  325.             // OutRequestHandler
  326.             GestoreHandlers.tipiOutRequestHandlersBuiltIn = GestoreHandlers.properties.getOutRequestHandlerBuiltIn();
  327.             GestoreHandlers.tipiOutRequestHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiOutRequestHandlersBuiltIn);
  328.             if(GestoreHandlers.tipiOutRequestHandlersBuiltIn!=null){
  329.                 GestoreHandlers.outRequestHandlersBuiltIn = new OutRequestHandler[GestoreHandlers.tipiOutRequestHandlersBuiltIn.length];
  330.                 for(int i=0; i<GestoreHandlers.tipiOutRequestHandlersBuiltIn.length; i++){
  331.                     try{
  332.                         String tipo=GestoreHandlers.tipiOutRequestHandlersBuiltIn[i];
  333.                         String classe = null;
  334.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  335.                             classe = NotifierOutRequestHandler.class.getName();
  336.                         }else{
  337.                             classe = classNameProperties.getOutRequestHandlerBuiltIn(tipo);
  338.                         }
  339.                         GestoreHandlers.outRequestHandlersBuiltIn[i] = (OutRequestHandler) loader.newInstance(classe);
  340.                         if(printInfoBuiltIn)
  341.                             logConsoleInit.info("OutRequestHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  342.                     }catch(Throwable e){
  343.                         if(msgDiag!=null) {
  344.                             msgDiag.logErroreGenerico(e, "Inizializzazione OutRequestHandler BuiltIn ["+GestoreHandlers.tipiOutRequestHandlersBuiltIn[i]+"]");
  345.                         }
  346.                         else if(logCore!=null) {
  347.                             logCore.error("Inizializzazione OutRequestHandler BuiltIn ["+GestoreHandlers.tipiOutRequestHandlersBuiltIn[i]+"]", e);
  348.                         }
  349.                     }
  350.                 }
  351.                 GestoreHandlers.outRequestHandlersBuiltIn = reorder(GestoreHandlers.outRequestHandlersBuiltIn, new OutRequestHandler[1]);
  352.             }
  353.             
  354.             // PostOutRequestHandler
  355.             GestoreHandlers.tipiPostOutRequestHandlersBuiltIn = properties.getPostOutRequestHandlerBuiltIn();
  356.             GestoreHandlers.tipiPostOutRequestHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiPostOutRequestHandlersBuiltIn);
  357.             if(GestoreHandlers.tipiPostOutRequestHandlersBuiltIn!=null){
  358.                 GestoreHandlers.postOutRequestHandlersBuiltIn = new PostOutRequestHandler[GestoreHandlers.tipiPostOutRequestHandlersBuiltIn.length];
  359.                 for(int i=0; i<GestoreHandlers.tipiPostOutRequestHandlersBuiltIn.length; i++){
  360.                     try{
  361.                         String tipo=GestoreHandlers.tipiPostOutRequestHandlersBuiltIn[i];
  362.                         String classe = null;
  363.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  364.                             classe = NotifierPostOutRequestHandler.class.getName();
  365.                         }else{
  366.                             classe = classNameProperties.getPostOutRequestHandlerBuiltIn(tipo);
  367.                         }
  368.                         GestoreHandlers.postOutRequestHandlersBuiltIn[i] = (PostOutRequestHandler) loader.newInstance(classe);
  369.                         if(printInfoBuiltIn)
  370.                             logConsoleInit.info("PostOutRequestHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  371.                     }catch(Throwable e){
  372.                         if(msgDiag!=null) {
  373.                             msgDiag.logErroreGenerico(e, "Inizializzazione PostOutRequestHandler BuiltIn ["+GestoreHandlers.tipiPostOutRequestHandlersBuiltIn[i]+"]");
  374.                         }
  375.                         else if(logCore!=null) {
  376.                             logCore.error("Inizializzazione PostOutRequestHandler BuiltIn ["+GestoreHandlers.tipiPostOutRequestHandlersBuiltIn[i]+"]", e);
  377.                         }
  378.                     }
  379.                 }
  380.                 GestoreHandlers.postOutRequestHandlersBuiltIn = reorder(GestoreHandlers.postOutRequestHandlersBuiltIn, new PostOutRequestHandler[1]);
  381.             }
  382.             
  383.             // PreInResponseHandler
  384.             GestoreHandlers.tipiPreInResponseHandlersBuiltIn = properties.getPreInResponseHandlerBuiltIn();
  385.             GestoreHandlers.tipiPreInResponseHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiPreInResponseHandlersBuiltIn);
  386.             if(GestoreHandlers.tipiPreInResponseHandlersBuiltIn!=null){
  387.                 GestoreHandlers.preInResponseHandlersBuiltIn = new PreInResponseHandler[GestoreHandlers.tipiPreInResponseHandlersBuiltIn.length];
  388.                 for(int i=0; i<GestoreHandlers.tipiPreInResponseHandlersBuiltIn.length; i++){
  389.                     try{
  390.                         String tipo=GestoreHandlers.tipiPreInResponseHandlersBuiltIn[i];
  391.                         String classe = null;
  392.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  393.                             classe = NotifierPreInResponseHandler.class.getName();
  394.                         }else{
  395.                             classe = classNameProperties.getPreInResponseHandlerBuiltIn(tipo);
  396.                         }
  397.                         GestoreHandlers.preInResponseHandlersBuiltIn[i] = (PreInResponseHandler) loader.newInstance(classe);
  398.                         if(printInfoBuiltIn)
  399.                             logConsoleInit.info("PreInResponseHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  400.                     }catch(Throwable e){
  401.                         if(msgDiag!=null) {
  402.                             msgDiag.logErroreGenerico(e, "Inizializzazione PreInResponseHandler BuiltIn ["+GestoreHandlers.tipiPreInResponseHandlersBuiltIn[i]+"]");
  403.                         }
  404.                         else if(logCore!=null) {
  405.                             logCore.error("Inizializzazione PreInResponseHandler BuiltIn ["+GestoreHandlers.tipiPreInResponseHandlersBuiltIn[i]+"]", e);
  406.                         }
  407.                     }
  408.                 }
  409.                 GestoreHandlers.preInResponseHandlersBuiltIn = reorder(GestoreHandlers.preInResponseHandlersBuiltIn, new PreInResponseHandler[1]);
  410.             }
  411.             
  412.             // InResponseHandler
  413.             GestoreHandlers.tipiInResponseHandlersBuiltIn = GestoreHandlers.properties.getInResponseHandlerBuiltIn();
  414.             GestoreHandlers.tipiInResponseHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiInResponseHandlersBuiltIn);
  415.             if(GestoreHandlers.tipiInResponseHandlersBuiltIn!=null){
  416.                 GestoreHandlers.inResponseHandlersBuiltIn = new InResponseHandler[GestoreHandlers.tipiInResponseHandlersBuiltIn.length];
  417.                 for(int i=0; i<GestoreHandlers.tipiInResponseHandlersBuiltIn.length; i++){
  418.                     try{
  419.                         String tipo=GestoreHandlers.tipiInResponseHandlersBuiltIn[i];
  420.                         String classe = null;
  421.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  422.                             classe = NotifierInResponseHandler.class.getName();
  423.                         }else{
  424.                             classe = classNameProperties.getInResponseHandlerBuiltIn(tipo);
  425.                         }
  426.                         GestoreHandlers.inResponseHandlersBuiltIn[i] = (InResponseHandler) loader.newInstance(classe);
  427.                         if(printInfoBuiltIn)
  428.                             logConsoleInit.info("InResponseHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  429.                     }catch(Throwable e){
  430.                         if(msgDiag!=null) {
  431.                             msgDiag.logErroreGenerico(e, "Inizializzazione InResponseHandler BuiltIn ["+GestoreHandlers.tipiInResponseHandlersBuiltIn[i]+"]");
  432.                         }
  433.                         else if(logCore!=null) {
  434.                             logCore.error("Inizializzazione InResponseHandler BuiltIn ["+GestoreHandlers.tipiInResponseHandlersBuiltIn[i]+"]", e);
  435.                         }
  436.                     }
  437.                 }
  438.                 GestoreHandlers.inResponseHandlersBuiltIn = reorder(GestoreHandlers.inResponseHandlersBuiltIn, new InResponseHandler[1]);
  439.             }
  440.             
  441.             // OutResponseHandler
  442.             GestoreHandlers.tipiOutResponseHandlersBuiltIn = GestoreHandlers.properties.getOutResponseHandlerBuiltIn();
  443.             GestoreHandlers.tipiOutResponseHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiOutResponseHandlersBuiltIn);
  444.             if(GestoreHandlers.tipiOutResponseHandlersBuiltIn!=null){
  445.                 GestoreHandlers.outResponseHandlersBuiltIn = new OutResponseHandler[GestoreHandlers.tipiOutResponseHandlersBuiltIn.length];
  446.                 for(int i=0; i<GestoreHandlers.tipiOutResponseHandlersBuiltIn.length; i++){
  447.                     try{
  448.                         String tipo=GestoreHandlers.tipiOutResponseHandlersBuiltIn[i];
  449.                         String classe = null;
  450.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  451.                             classe = NotifierOutResponseHandler.class.getName();
  452.                         }else{
  453.                             classe = classNameProperties.getOutResponseHandlerBuiltIn(tipo);
  454.                         }
  455.                         GestoreHandlers.outResponseHandlersBuiltIn[i] = (OutResponseHandler) loader.newInstance(classe);
  456.                         if(printInfoBuiltIn)
  457.                             logConsoleInit.info("OutResponseHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  458.                     }catch(Throwable e){
  459.                         if(msgDiag!=null) {
  460.                             msgDiag.logErroreGenerico(e, "Inizializzazione OutResponseHandler BuiltIn ["+GestoreHandlers.tipiOutResponseHandlersBuiltIn[i]+"]");
  461.                         }
  462.                         else if(logCore!=null) {
  463.                             logCore.error("Inizializzazione OutResponseHandler BuiltIn ["+GestoreHandlers.tipiOutResponseHandlersBuiltIn[i]+"]", e);
  464.                         }
  465.                     }
  466.                 }
  467.                 GestoreHandlers.outResponseHandlersBuiltIn = reorder(GestoreHandlers.outResponseHandlersBuiltIn, new OutResponseHandler[1]);
  468.             }
  469.             
  470.             // PostOutResponseHandler
  471.             GestoreHandlers.tipiPostOutResponseHandlersBuiltIn = GestoreHandlers.properties.getPostOutResponseHandlerBuiltIn();
  472.             GestoreHandlers.tipiPostOutResponseHandlersBuiltIn = updateNotifierCallback(GestoreHandlers.tipiPostOutResponseHandlersBuiltIn);
  473.             if(GestoreHandlers.tipiPostOutResponseHandlersBuiltIn!=null){
  474.                 GestoreHandlers.postOutResponseHandlersBuiltIn = new PostOutResponseHandler[GestoreHandlers.tipiPostOutResponseHandlersBuiltIn.length];
  475.                 for(int i=0; i<GestoreHandlers.tipiPostOutResponseHandlersBuiltIn.length; i++){
  476.                     try{
  477.                         String tipo=GestoreHandlers.tipiPostOutResponseHandlersBuiltIn[i];
  478.                         String classe = null;
  479.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  480.                             classe = NotifierPostOutResponseHandler.class.getName();
  481.                         }else{
  482.                             classe = classNameProperties.getPostOutResponseHandlerBuiltIn(tipo);
  483.                         }
  484.                         GestoreHandlers.postOutResponseHandlersBuiltIn[i] = (PostOutResponseHandler) loader.newInstance(classe);
  485.                         if(printInfoBuiltIn)
  486.                             logConsoleInit.info("PostOutResponseHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  487.                     }catch(Throwable e){
  488.                         if(msgDiag!=null) {
  489.                             msgDiag.logErroreGenerico(e, "Inizializzazione PostOutResponseHandler BuiltIn ["+GestoreHandlers.tipiPostOutResponseHandlersBuiltIn[i]+"]");
  490.                         }
  491.                         else if(logCore!=null) {
  492.                             logCore.error("Inizializzazione PostOutResponseHandler BuiltIn ["+GestoreHandlers.tipiPostOutResponseHandlersBuiltIn[i]+"]", e);
  493.                         }
  494.                     }
  495.                 }
  496.                 GestoreHandlers.postOutResponseHandlersBuiltIn = reorder(GestoreHandlers.postOutResponseHandlersBuiltIn, new PostOutResponseHandler[1]);
  497.             }
  498.             
  499.             // IntegrationManagerRequestHandler
  500.             GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn = GestoreHandlers.properties.getIntegrationManagerRequestHandlerBuiltIn();
  501.             if(GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn!=null){
  502.                 GestoreHandlers.integrationManagerRequestHandlersBuiltIn = new IntegrationManagerRequestHandler[GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn.length];
  503.                 for(int i=0; i<GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn.length; i++){
  504.                     try{
  505.                         String tipo=GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn[i];
  506.                         String classe = classNameProperties.getIntegrationManagerRequestHandlerBuiltIn(tipo);
  507.                         GestoreHandlers.integrationManagerRequestHandlersBuiltIn[i] = (IntegrationManagerRequestHandler) loader.newInstance(classe);
  508.                         if(printInfoBuiltIn)
  509.                             logConsoleInit.info("IntegrationManagerRequestHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  510.                     }catch(Throwable e){
  511.                         if(msgDiag!=null) {
  512.                             msgDiag.logErroreGenerico(e, "Inizializzazione IntegrationManagerRequestHandler BuiltIn ["+GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn[i]+"]");
  513.                         }
  514.                         else if(logCore!=null) {
  515.                             logCore.error("Inizializzazione IntegrationManagerRequestHandler BuiltIn ["+GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn[i]+"]", e);
  516.                         }
  517.                     }
  518.                 }
  519.                 GestoreHandlers.integrationManagerRequestHandlersBuiltIn = reorder(GestoreHandlers.integrationManagerRequestHandlersBuiltIn, new IntegrationManagerRequestHandler[1]);
  520.             }
  521.             
  522.             // IntegrationManagerResponseHandler
  523.             GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn = GestoreHandlers.properties.getIntegrationManagerResponseHandlerBuiltIn();
  524.             if(GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn!=null){
  525.                 GestoreHandlers.integrationManagerResponseHandlersBuiltIn = new IntegrationManagerResponseHandler[GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn.length];
  526.                 for(int i=0; i<GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn.length; i++){
  527.                     try{
  528.                         String tipo=GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn[i];
  529.                         String classe = classNameProperties.getIntegrationManagerResponseHandlerBuiltIn(tipo);
  530.                         GestoreHandlers.integrationManagerResponseHandlersBuiltIn[i] = (IntegrationManagerResponseHandler) loader.newInstance(classe);
  531.                         if(printInfoBuiltIn)
  532.                             logConsoleInit.info("IntegrationManagerResponseHandler BuiltIn di tipo ["+tipo+"] correttamente inizializzato.");
  533.                     }catch(Throwable e){
  534.                         if(msgDiag!=null) {
  535.                             msgDiag.logErroreGenerico(e, "Inizializzazione IntegrationManagerResponseHandler BuiltIn ["+GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn[i]+"]");
  536.                         }
  537.                         else if(logCore!=null) {
  538.                             logCore.error("Inizializzazione IntegrationManagerResponseHandler BuiltIn ["+GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn[i]+"]", e);
  539.                         }
  540.                     }
  541.                 }
  542.                 GestoreHandlers.integrationManagerResponseHandlersBuiltIn = reorder(GestoreHandlers.integrationManagerResponseHandlersBuiltIn, new IntegrationManagerResponseHandler[1]);
  543.             }
  544.             
  545.             
  546.             
  547.             // Handlers Utente

  549.             boolean printInfo = GestoreHandlers.properties.isPrintInfoHandler();
  550.             
  551.             // InitHandler
  552.             List<String> tipiInitHandlersConfig = null;
  553.             try {
  554.                 tipiInitHandlersConfig=ConfigurazionePdDManager.getInstance(state).getInitHandlers();
  555.             }catch(Throwable e) {
  556.                 if(msgDiag!=null) {
  557.                     msgDiag.logErroreGenerico(e, "Raccolta InitHandlers");
  558.                 }
  559.                 else if(logCore!=null) {
  560.                     logCore.error("Raccolta InitHandlers", e);
  561.                 }
  562.             }
  563.             GestoreHandlers.tipiInitHandlers = _mergeTipi(GestoreHandlers.properties.getInitHandler(),
  564.                     tipiInitHandlersConfig);
  565.             if(GestoreHandlers.tipiInitHandlers!=null){
  566.                 GestoreHandlers.initHandlers = new InitHandler[GestoreHandlers.tipiInitHandlers.length];
  567.                 for(int i=0; i<GestoreHandlers.tipiInitHandlers.length; i++){
  568.                     try{
  569.                         String tipo=GestoreHandlers.tipiInitHandlers[i];
  570.                         GestoreHandlers.initHandlers[i] = (InitHandler) pluginLoader.newInitHandler(tipo);
  571.                         if(printInfo)
  572.                             logConsoleInit.info("InitHandler di tipo ["+tipo+"] correttamente inizializzato.");
  573.                     }catch(Throwable e){
  574.                         if(msgDiag!=null) {
  575.                             msgDiag.logErroreGenerico(e, "Inizializzazione InitHandler ["+GestoreHandlers.tipiInitHandlers[i]+"]");
  576.                         }
  577.                         else if(logCore!=null) {
  578.                             logCore.error("Inizializzazione InitHandler ["+GestoreHandlers.tipiInitHandlers[i]+"]", e);
  579.                         }
  580.                     }
  581.                 }
  582.                 GestoreHandlers.initHandlers = reorder(GestoreHandlers.initHandlers, new InitHandler[1]);
  583.             }
  584.             
  585.             // ExitHandler
  586.             List<String> tipiExitHandlersConfig = null;
  587.             try {
  588.                 tipiExitHandlersConfig=ConfigurazionePdDManager.getInstance(state).getExitHandlers();
  589.             }catch(Throwable e) {
  590.                 if(msgDiag!=null) {
  591.                     msgDiag.logErroreGenerico(e, "Raccolta ExitHandlers");
  592.                 }
  593.                 else if(logCore!=null) {
  594.                     logCore.error("Raccolta ExitHandlers", e);
  595.                 }
  596.             }
  597.             GestoreHandlers.tipiExitHandlers = _mergeTipi(GestoreHandlers.properties.getExitHandler(),
  598.                     tipiExitHandlersConfig);
  599.             if(GestoreHandlers.tipiExitHandlers!=null){
  600.                 GestoreHandlers.exitHandlers = new ExitHandler[GestoreHandlers.tipiExitHandlers.length];
  601.                 for(int i=0; i<GestoreHandlers.tipiExitHandlers.length; i++){
  602.                     try{
  603.                         String tipo=GestoreHandlers.tipiExitHandlers[i];
  604.                         GestoreHandlers.exitHandlers[i] = (ExitHandler) pluginLoader.newExitHandler(tipo);
  605.                         if(printInfo)
  606.                             logConsoleInit.info("ExitHandler di tipo ["+tipo+"] correttamente inizializzato.");
  607.                     }catch(Throwable e){
  608.                         if(msgDiag!=null) {
  609.                             msgDiag.logErroreGenerico(e, "Inizializzazione ExitHandler ["+GestoreHandlers.tipiExitHandlers[i]+"]");
  610.                         }
  611.                         else if(logCore!=null) {
  612.                             logCore.error("Inizializzazione ExitHandler ["+GestoreHandlers.tipiExitHandlers[i]+"]", e);
  613.                         }
  614.                     }
  615.                 }
  616.                 GestoreHandlers.exitHandlers = reorder(GestoreHandlers.exitHandlers, new ExitHandler[1]);
  617.             }
  618.             
  619.             // PreInRequestHandler
  620.             List<String> tipiPreInRequestHandlersConfig = null;
  621.             try {
  622.                 tipiPreInRequestHandlersConfig=ConfigurazionePdDManager.getInstance(state).getPreInRequestHandlers();
  623.             }catch(Throwable e) {
  624.                 if(msgDiag!=null) {
  625.                     msgDiag.logErroreGenerico(e, "Raccolta PreInRequestHandlers");
  626.                 }
  627.                 else if(logCore!=null) {
  628.                     logCore.error("Raccolta PreInRequestHandlers", e);
  629.                 }
  630.             }
  631.             GestoreHandlers.tipiPreInRequestHandlers = _mergeTipi(GestoreHandlers.properties.getPreInRequestHandler(),
  632.                     tipiPreInRequestHandlersConfig);
  633.             GestoreHandlers.tipiPreInRequestHandlers = updateNotifierCallback(GestoreHandlers.tipiPreInRequestHandlers);
  634.             if(GestoreHandlers.tipiPreInRequestHandlers!=null){
  635.                 GestoreHandlers.preInRequestHandlers = new PreInRequestHandler[GestoreHandlers.tipiPreInRequestHandlers.length];
  636.                 for(int i=0; i<GestoreHandlers.tipiPreInRequestHandlers.length; i++){
  637.                     try{
  638.                         String tipo=GestoreHandlers.tipiPreInRequestHandlers[i];
  639.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  640.                             String classe = NotifierPreInRequestHandler.class.getName();
  641.                             GestoreHandlers.preInRequestHandlers[i] = (PreInRequestHandler) loader.newInstance(classe);
  642.                         }else{
  643.                             GestoreHandlers.preInRequestHandlers[i] = pluginLoader.newPreInRequestHandler(tipo);
  644.                         }
  645.                         if(printInfo)
  646.                             logConsoleInit.info("PreInRequestHandler di tipo ["+tipo+"] correttamente inizializzato.");
  647.                     }catch(Throwable e){
  648.                         if(msgDiag!=null) {
  649.                             msgDiag.logErroreGenerico(e, "Inizializzazione PreInRequestHandler ["+GestoreHandlers.tipiPreInRequestHandlers[i]+"]");
  650.                         }
  651.                         else if(logCore!=null) {
  652.                             logCore.error("Inizializzazione PreInRequestHandler ["+GestoreHandlers.tipiPreInRequestHandlers[i]+"]", e);
  653.                         }
  654.                     }
  655.                 }
  656.                 GestoreHandlers.preInRequestHandlers = reorder(GestoreHandlers.preInRequestHandlers, new PreInRequestHandler[1]);
  657.             }
  658.             
  659.             // InRequestHandler
  660.             List<String> tipiInRequestHandlersConfig = null;
  661.             try {
  662.                 tipiInRequestHandlersConfig=ConfigurazionePdDManager.getInstance(state).getInRequestHandlers();
  663.             }catch(Throwable e) {
  664.                 if(msgDiag!=null) {
  665.                     msgDiag.logErroreGenerico(e, "Raccolta InRequestHandlers");
  666.                 }
  667.                 else if(logCore!=null) {
  668.                     logCore.error("Raccolta InRequestHandlers", e);
  669.                 }
  670.             }
  671.             GestoreHandlers.tipiInRequestHandlers = _mergeTipi(GestoreHandlers.properties.getInRequestHandler(),
  672.                     tipiInRequestHandlersConfig);
  673.             GestoreHandlers.tipiInRequestHandlers = updateNotifierCallback(GestoreHandlers.tipiInRequestHandlers);
  674.             if(GestoreHandlers.tipiInRequestHandlers!=null){
  675.                 GestoreHandlers.inRequestHandlers = new InRequestHandler[GestoreHandlers.tipiInRequestHandlers.length];
  676.                 for(int i=0; i<GestoreHandlers.tipiInRequestHandlers.length; i++){
  677.                     try{
  678.                         String tipo=GestoreHandlers.tipiInRequestHandlers[i];
  679.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  680.                             String classe = NotifierInRequestHandler.class.getName();
  681.                             GestoreHandlers.inRequestHandlers[i] = (InRequestHandler) loader.newInstance(classe);
  682.                         }else{
  683.                             GestoreHandlers.inRequestHandlers[i] = pluginLoader.newInRequestHandler(tipo);
  684.                         }
  685.                         if(printInfo)
  686.                             logConsoleInit.info("InRequestHandler di tipo ["+tipo+"] correttamente inizializzato.");
  687.                     }catch(Throwable e){
  688.                         if(msgDiag!=null) {
  689.                             msgDiag.logErroreGenerico(e, "Inizializzazione InRequestHandler ["+GestoreHandlers.tipiInRequestHandlers[i]+"]");
  690.                         }
  691.                         else if(logCore!=null) {
  692.                             logCore.error("Inizializzazione InRequestHandler ["+GestoreHandlers.tipiInRequestHandlers[i]+"]", e);
  693.                         }
  694.                     }
  695.                 }
  696.                 GestoreHandlers.inRequestHandlers = reorder(GestoreHandlers.inRequestHandlers, new InRequestHandler[1]);
  697.             }
  698.             
  699.             // InRequestProtocolHandler
  700.             List<String> tipiInRequestProtocolHandlersConfig = null;
  701.             try {
  702.                 tipiInRequestProtocolHandlersConfig=ConfigurazionePdDManager.getInstance(state).getInRequestProtocolHandlers();
  703.             }catch(Throwable e) {
  704.                 if(msgDiag!=null) {
  705.                     msgDiag.logErroreGenerico(e, "Raccolta InRequestProtocolHandlers");
  706.                 }
  707.                 else if(logCore!=null) {
  708.                     logCore.error("Raccolta InRequestProtocolHandlers", e);
  709.                 }
  710.             }
  711.             GestoreHandlers.tipiInRequestProtocolHandlers = _mergeTipi(GestoreHandlers.properties.getInRequestProtocolHandler(),
  712.                     tipiInRequestProtocolHandlersConfig);
  713.             GestoreHandlers.tipiInRequestProtocolHandlers = updateNotifierCallback(GestoreHandlers.tipiInRequestProtocolHandlers);
  714.             if(GestoreHandlers.tipiInRequestProtocolHandlers!=null){
  715.                 GestoreHandlers.inRequestProtocolHandlers = new InRequestProtocolHandler[GestoreHandlers.tipiInRequestProtocolHandlers.length];
  716.                 for(int i=0; i<GestoreHandlers.tipiInRequestProtocolHandlers.length; i++){
  717.                     try{
  718.                         String tipo=GestoreHandlers.tipiInRequestProtocolHandlers[i];
  719.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  720.                             String classe = NotifierInRequestProtocolHandler.class.getName();
  721.                             GestoreHandlers.inRequestProtocolHandlers[i] = (InRequestProtocolHandler) loader.newInstance(classe);
  722.                         }else{
  723.                             GestoreHandlers.inRequestProtocolHandlers[i] = pluginLoader.newInRequestProtocolHandler(tipo);
  724.                         }
  725.                         if(printInfo)
  726.                             logConsoleInit.info("InRequestProtocolHandler di tipo ["+tipo+"] correttamente inizializzato.");
  727.                     }catch(Throwable e){
  728.                         if(msgDiag!=null) {
  729.                             msgDiag.logErroreGenerico(e, "Inizializzazione InRequestProtocolHandler ["+GestoreHandlers.tipiInRequestProtocolHandlers[i]+"]");
  730.                         }
  731.                         else if(logCore!=null) {
  732.                             logCore.error("Inizializzazione InRequestProtocolHandler ["+GestoreHandlers.tipiInRequestProtocolHandlers[i]+"]", e);
  733.                         }
  734.                     }
  735.                 }
  736.                 GestoreHandlers.inRequestProtocolHandlers = reorder(GestoreHandlers.inRequestProtocolHandlers, new InRequestProtocolHandler[1]);
  737.             }
  738.             
  739.             // OutRequestHandler
  740.             List<String> tipiOutRequestHandlersConfig = null;
  741.             try {
  742.                 tipiOutRequestHandlersConfig=ConfigurazionePdDManager.getInstance(state).getOutRequestHandlers();
  743.             }catch(Throwable e) {
  744.                 if(msgDiag!=null) {
  745.                     msgDiag.logErroreGenerico(e, "Raccolta OutRequestHandlers");
  746.                 }
  747.                 else if(logCore!=null) {
  748.                     logCore.error("Raccolta OutRequestHandlers", e);
  749.                 }
  750.             }
  751.             GestoreHandlers.tipiOutRequestHandlers = _mergeTipi(GestoreHandlers.properties.getOutRequestHandler(),
  752.                     tipiOutRequestHandlersConfig);
  753.             GestoreHandlers.tipiOutRequestHandlers = updateNotifierCallback(GestoreHandlers.tipiOutRequestHandlers);
  754.             if(GestoreHandlers.tipiOutRequestHandlers!=null){
  755.                 GestoreHandlers.outRequestHandlers = new OutRequestHandler[GestoreHandlers.tipiOutRequestHandlers.length];
  756.                 for(int i=0; i<GestoreHandlers.tipiOutRequestHandlers.length; i++){
  757.                     try{
  758.                         String tipo=GestoreHandlers.tipiOutRequestHandlers[i];
  759.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  760.                             String classe = NotifierOutRequestHandler.class.getName();
  761.                             GestoreHandlers.outRequestHandlers[i] = (OutRequestHandler) loader.newInstance(classe);
  762.                         }else{
  763.                             GestoreHandlers.outRequestHandlers[i] = pluginLoader.newOutRequestHandler(tipo);
  764.                         }
  765.                         if(printInfo)
  766.                             logConsoleInit.info("OutRequestHandler di tipo ["+tipo+"] correttamente inizializzato.");
  767.                     }catch(Throwable e){
  768.                         if(msgDiag!=null) {
  769.                             msgDiag.logErroreGenerico(e, "Inizializzazione OutRequestHandler ["+GestoreHandlers.tipiOutRequestHandlers[i]+"]");
  770.                         }
  771.                         else if(logCore!=null) {
  772.                             logCore.error("Inizializzazione OutRequestHandler ["+GestoreHandlers.tipiOutRequestHandlers[i]+"]", e);
  773.                         }
  774.                     }
  775.                 }
  776.                 GestoreHandlers.outRequestHandlers = reorder(GestoreHandlers.outRequestHandlers, new OutRequestHandler[1]);
  777.             }
  778.             
  779.             // PostOutRequestHandler
  780.             List<String> tipiPostOutRequestHandlersConfig = null;
  781.             try {
  782.                 tipiPostOutRequestHandlersConfig=ConfigurazionePdDManager.getInstance(state).getPostOutRequestHandlers();
  783.             }catch(Throwable e) {
  784.                 if(msgDiag!=null) {
  785.                     msgDiag.logErroreGenerico(e, "Raccolta PostOutRequestHandlers");
  786.                 }
  787.                 else if(logCore!=null) {
  788.                     logCore.error("Raccolta PostOutRequestHandlers", e);
  789.                 }
  790.             }
  791.             GestoreHandlers.tipiPostOutRequestHandlers = _mergeTipi(GestoreHandlers.properties.getPostOutRequestHandler(),
  792.                     tipiPostOutRequestHandlersConfig);
  793.             GestoreHandlers.tipiPostOutRequestHandlers = updateNotifierCallback(GestoreHandlers.tipiPostOutRequestHandlers);
  794.             if(GestoreHandlers.tipiPostOutRequestHandlers!=null){
  795.                 GestoreHandlers.postOutRequestHandlers = new PostOutRequestHandler[GestoreHandlers.tipiPostOutRequestHandlers.length];
  796.                 for(int i=0; i<GestoreHandlers.tipiPostOutRequestHandlers.length; i++){
  797.                     try{
  798.                         String tipo=GestoreHandlers.tipiPostOutRequestHandlers[i];
  799.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  800.                             String classe = NotifierPostOutRequestHandler.class.getName();
  801.                             GestoreHandlers.postOutRequestHandlers[i] = (PostOutRequestHandler) loader.newInstance(classe);
  802.                         }else{
  803.                             GestoreHandlers.postOutRequestHandlers[i] = pluginLoader.newPostOutRequestHandler(tipo);
  804.                         }
  805.                         if(printInfo)
  806.                             logConsoleInit.info("PostOutRequestHandler di tipo ["+tipo+"] correttamente inizializzato.");
  807.                     }catch(Throwable e){
  808.                         if(msgDiag!=null) {
  809.                             msgDiag.logErroreGenerico(e, "Inizializzazione PostOutRequestHandler ["+GestoreHandlers.tipiPostOutRequestHandlers[i]+"]");
  810.                         }
  811.                         else if(logCore!=null) {
  812.                             logCore.error("Inizializzazione PostOutRequestHandler ["+GestoreHandlers.tipiPostOutRequestHandlers[i]+"]", e);
  813.                         }
  814.                     }
  815.                 }
  816.                 GestoreHandlers.postOutRequestHandlers = reorder(GestoreHandlers.postOutRequestHandlers, new PostOutRequestHandler[1]);
  817.             }
  818.             
  819.             // PreInResponseHandler
  820.             List<String> tipiPreInResponseHandlersConfig = null;
  821.             try {
  822.                 tipiPreInResponseHandlersConfig=ConfigurazionePdDManager.getInstance(state).getPreInResponseHandlers();
  823.             }catch(Throwable e) {
  824.                 if(msgDiag!=null) {
  825.                     msgDiag.logErroreGenerico(e, "Raccolta PreInResponseHandlers");
  826.                 }
  827.                 else if(logCore!=null) {
  828.                     logCore.error("Raccolta PreInResponseHandlers", e);
  829.                 }
  830.             }
  831.             GestoreHandlers.tipiPreInResponseHandlers = _mergeTipi(GestoreHandlers.properties.getPreInResponseHandler(),
  832.                     tipiPreInResponseHandlersConfig);
  833.             GestoreHandlers.tipiPreInResponseHandlers = updateNotifierCallback(GestoreHandlers.tipiPreInResponseHandlers);
  834.             if(GestoreHandlers.tipiPreInResponseHandlers!=null){
  835.                 GestoreHandlers.preInResponseHandlers = new PreInResponseHandler[GestoreHandlers.tipiPreInResponseHandlers.length];
  836.                 for(int i=0; i<GestoreHandlers.tipiPreInResponseHandlers.length; i++){
  837.                     try{
  838.                         String tipo=GestoreHandlers.tipiPreInResponseHandlers[i];
  839.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  840.                             String classe = NotifierPreInResponseHandler.class.getName();
  841.                             GestoreHandlers.preInResponseHandlers[i] = (PreInResponseHandler) loader.newInstance(classe);
  842.                         }else{
  843.                             GestoreHandlers.preInResponseHandlers[i] = pluginLoader.newPreInResponseHandler(tipo);
  844.                         }
  845.                         if(printInfo)
  846.                             logConsoleInit.info("PreInResponseHandler di tipo ["+tipo+"] correttamente inizializzato.");
  847.                     }catch(Throwable e){
  848.                         if(msgDiag!=null) {
  849.                             msgDiag.logErroreGenerico(e, "Inizializzazione PreInResponseHandler ["+GestoreHandlers.tipiPreInResponseHandlers[i]+"]");
  850.                         }
  851.                         else if(logCore!=null) {
  852.                             logCore.error("Inizializzazione PreInResponseHandler ["+GestoreHandlers.tipiPreInResponseHandlers[i]+"]", e);
  853.                         }
  854.                     }
  855.                 }
  856.                 GestoreHandlers.preInResponseHandlers = reorder(GestoreHandlers.preInResponseHandlers, new PreInResponseHandler[1]);
  857.             }
  858.             
  859.             // InResponseHandler
  860.             List<String> tipiInResponseHandlersConfig = null;
  861.             try {
  862.                 tipiInResponseHandlersConfig=ConfigurazionePdDManager.getInstance(state).getInResponseHandlers();
  863.             }catch(Throwable e) {
  864.                 if(msgDiag!=null) {
  865.                     msgDiag.logErroreGenerico(e, "Raccolta InResponseHandlers");
  866.                 }
  867.                 else if(logCore!=null) {
  868.                     logCore.error("Raccolta InResponseHandlers", e);
  869.                 }
  870.             }
  871.             GestoreHandlers.tipiInResponseHandlers = _mergeTipi(GestoreHandlers.properties.getInResponseHandler(),
  872.                     tipiInResponseHandlersConfig);
  873.             GestoreHandlers.tipiInResponseHandlers = updateNotifierCallback(GestoreHandlers.tipiInResponseHandlers);
  874.             if(GestoreHandlers.tipiInResponseHandlers!=null){
  875.                 GestoreHandlers.inResponseHandlers = new InResponseHandler[GestoreHandlers.tipiInResponseHandlers.length];
  876.                 for(int i=0; i<GestoreHandlers.tipiInResponseHandlers.length; i++){
  877.                     try{
  878.                         String tipo=GestoreHandlers.tipiInResponseHandlers[i];
  879.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  880.                             String classe = NotifierInResponseHandler.class.getName();
  881.                             GestoreHandlers.inResponseHandlers[i] = (InResponseHandler) loader.newInstance(classe);
  882.                         }else{
  883.                             GestoreHandlers.inResponseHandlers[i] = pluginLoader.newInResponseHandler(tipo);
  884.                         }
  885.                         if(printInfo)
  886.                             logConsoleInit.info("InResponseHandler di tipo ["+tipo+"] correttamente inizializzato.");
  887.                     }catch(Throwable e){
  888.                         if(msgDiag!=null) {
  889.                             msgDiag.logErroreGenerico(e, "Inizializzazione InResponseHandler ["+GestoreHandlers.tipiInResponseHandlers[i]+"]");
  890.                         }
  891.                         else if(logCore!=null) {
  892.                             logCore.error("Inizializzazione InResponseHandler ["+GestoreHandlers.tipiInResponseHandlers[i]+"]", e);
  893.                         }
  894.                     }
  895.                 }
  896.                 GestoreHandlers.inResponseHandlers = reorder(GestoreHandlers.inResponseHandlers, new InResponseHandler[1]);
  897.             }
  898.             
  899.             // OutResponseHandler
  900.             List<String> tipiOutResponseHandlersConfig = null;
  901.             try {
  902.                 tipiOutResponseHandlersConfig=ConfigurazionePdDManager.getInstance(state).getOutResponseHandlers();
  903.             }catch(Throwable e) {
  904.                 if(msgDiag!=null) {
  905.                     msgDiag.logErroreGenerico(e, "Raccolta OutResponseHandlers");
  906.                 }
  907.                 else if(logCore!=null) {
  908.                     logCore.error("Raccolta OutResponseHandlers", e);
  909.                 }
  910.             }
  911.             GestoreHandlers.tipiOutResponseHandlers = _mergeTipi(GestoreHandlers.properties.getOutResponseHandler(),
  912.                     tipiOutResponseHandlersConfig);
  913.             GestoreHandlers.tipiOutResponseHandlers = updateNotifierCallback(GestoreHandlers.tipiOutResponseHandlers);
  914.             if(GestoreHandlers.tipiOutResponseHandlers!=null){
  915.                 GestoreHandlers.outResponseHandlers = new OutResponseHandler[GestoreHandlers.tipiOutResponseHandlers.length];
  916.                 for(int i=0; i<GestoreHandlers.tipiOutResponseHandlers.length; i++){
  917.                     try{
  918.                         String tipo=GestoreHandlers.tipiOutResponseHandlers[i];
  919.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  920.                             String classe = NotifierOutResponseHandler.class.getName();
  921.                             GestoreHandlers.outResponseHandlers[i] = (OutResponseHandler) loader.newInstance(classe);
  922.                         }else{
  923.                             GestoreHandlers.outResponseHandlers[i] = pluginLoader.newOutResponseHandler(tipo);
  924.                         }
  925.                         if(printInfo)
  926.                             logConsoleInit.info("OutResponseHandler di tipo ["+tipo+"] correttamente inizializzato.");
  927.                     }catch(Throwable e){
  928.                         if(msgDiag!=null) {
  929.                             msgDiag.logErroreGenerico(e, "Inizializzazione OutResponseHandler ["+GestoreHandlers.tipiOutResponseHandlers[i]+"]");
  930.                         }
  931.                         else if(logCore!=null) {
  932.                             logCore.error("Inizializzazione OutResponseHandler ["+GestoreHandlers.tipiOutResponseHandlers[i]+"]", e);
  933.                         }
  934.                     }
  935.                 }
  936.                 GestoreHandlers.outResponseHandlers = reorder(GestoreHandlers.outResponseHandlers, new OutResponseHandler[1]);
  937.             }
  938.             
  939.             // PostOutResponseHandler
  940.             List<String> tipiPostOutResponseHandlersConfig = null;
  941.             try {
  942.                 tipiPostOutResponseHandlersConfig=ConfigurazionePdDManager.getInstance(state).getPostOutResponseHandlers();
  943.             }catch(Throwable e) {
  944.                 if(msgDiag!=null) {
  945.                     msgDiag.logErroreGenerico(e, "Raccolta PostOutResponseHandlers");
  946.                 }
  947.                 else if(logCore!=null) {
  948.                     logCore.error("Raccolta PostOutResponseHandlers", e);
  949.                 }
  950.             }
  951.             GestoreHandlers.tipiPostOutResponseHandlers = _mergeTipi(GestoreHandlers.properties.getPostOutResponseHandler(),
  952.                     tipiPostOutResponseHandlersConfig);
  953.             GestoreHandlers.tipiPostOutResponseHandlers = updateNotifierCallback(GestoreHandlers.tipiPostOutResponseHandlers);
  954.             if(GestoreHandlers.tipiPostOutResponseHandlers!=null){
  955.                 GestoreHandlers.postOutResponseHandlers = new PostOutResponseHandler[GestoreHandlers.tipiPostOutResponseHandlers.length];
  956.                 for(int i=0; i<GestoreHandlers.tipiPostOutResponseHandlers.length; i++){
  957.                     try{
  958.                         String tipo=GestoreHandlers.tipiPostOutResponseHandlers[i];
  959.                         if(NotifierConstants.TIPO_NOTIFIER.equals(tipo)){
  960.                             String classe = NotifierPostOutResponseHandler.class.getName();
  961.                             GestoreHandlers.postOutResponseHandlers[i] = (PostOutResponseHandler) loader.newInstance(classe);
  962.                         }else{
  963.                             GestoreHandlers.postOutResponseHandlers[i] = pluginLoader.newPostOutResponseHandler(tipo);
  964.                         }
  965.                         if(printInfo)
  966.                             logConsoleInit.info("PostOutResponseHandler di tipo ["+tipo+"] correttamente inizializzato.");
  967.                     }catch(Throwable e){
  968.                         if(msgDiag!=null) {
  969.                             msgDiag.logErroreGenerico(e, "Inizializzazione PostOutResponseHandler ["+GestoreHandlers.tipiPostOutResponseHandlers[i]+"]");
  970.                         }
  971.                         else if(logCore!=null) {
  972.                             logCore.error("Inizializzazione PostOutResponseHandler ["+GestoreHandlers.tipiPostOutResponseHandlers[i]+"]", e);
  973.                         }
  974.                     }
  975.                 }
  976.                 GestoreHandlers.postOutResponseHandlers = reorder(GestoreHandlers.postOutResponseHandlers, new PostOutResponseHandler[1]);
  977.             }
  978.             
  979.             // IntegrationManagerRequestHandler
  980.             List<String> tipiIntegrationManagerRequestHandlersConfig = null;
  981.             try {
  982.                 tipiIntegrationManagerRequestHandlersConfig=ConfigurazionePdDManager.getInstance(state).getIntegrationManagerRequestHandlers();
  983.             }catch(Throwable e) {
  984.                 if(msgDiag!=null) {
  985.                     msgDiag.logErroreGenerico(e, "Raccolta IntegrationManagerRequestHandlers");
  986.                 }
  987.                 else if(logCore!=null) {
  988.                     logCore.error("Raccolta IntegrationManagerRequestHandlers", e);
  989.                 }
  990.             }
  991.             GestoreHandlers.tipiIntegrationManagerRequestHandlers = _mergeTipi(GestoreHandlers.properties.getIntegrationManagerRequestHandler(),
  992.                     tipiIntegrationManagerRequestHandlersConfig);
  993.             if(GestoreHandlers.tipiIntegrationManagerRequestHandlers!=null){
  994.                 GestoreHandlers.integrationManagerRequestHandlers = new IntegrationManagerRequestHandler[GestoreHandlers.tipiIntegrationManagerRequestHandlers.length];
  995.                 for(int i=0; i<GestoreHandlers.tipiIntegrationManagerRequestHandlers.length; i++){
  996.                     try{
  997.                         String tipo=GestoreHandlers.tipiIntegrationManagerRequestHandlers[i];
  998.                         GestoreHandlers.integrationManagerRequestHandlers[i] = (IntegrationManagerRequestHandler) pluginLoader.newIntegrationManagerRequestHandler(tipo);
  999.                         if(printInfo)
  1000.                             logConsoleInit.info("IntegrationManagerRequestHandler di tipo ["+tipo+"] correttamente inizializzato.");
  1001.                     }catch(Throwable e){
  1002.                         if(msgDiag!=null) {
  1003.                             msgDiag.logErroreGenerico(e, "Inizializzazione IntegrationManagerRequestHandler ["+GestoreHandlers.tipiIntegrationManagerRequestHandlers[i]+"]");
  1004.                         }
  1005.                         else if(logCore!=null) {
  1006.                             logCore.error("Inizializzazione IntegrationManagerRequestHandler ["+GestoreHandlers.tipiIntegrationManagerRequestHandlers[i]+"]", e);
  1007.                         }
  1008.                     }
  1009.                 }
  1010.                 GestoreHandlers.integrationManagerRequestHandlers = reorder(GestoreHandlers.integrationManagerRequestHandlers, new IntegrationManagerRequestHandler[1]);
  1011.             }
  1012.             
  1013.             // IntegrationManagerResponseHandler
  1014.             List<String> tipiIntegrationManagerResponseHandlersConfig = null;
  1015.             try {
  1016.                 tipiIntegrationManagerResponseHandlersConfig=ConfigurazionePdDManager.getInstance(state).getIntegrationManagerResponseHandlers();
  1017.             }catch(Throwable e) {
  1018.                 if(msgDiag!=null) {
  1019.                     msgDiag.logErroreGenerico(e, "Raccolta IntegrationManagerResponseHandlers");
  1020.                 }
  1021.                 else if(logCore!=null) {
  1022.                     logCore.error("Raccolta IntegrationManagerResponseHandlers", e);
  1023.                 }
  1024.             }
  1025.             GestoreHandlers.tipiIntegrationManagerResponseHandlers = _mergeTipi(GestoreHandlers.properties.getIntegrationManagerResponseHandler(),
  1026.                     tipiIntegrationManagerResponseHandlersConfig);
  1027.             if(GestoreHandlers.tipiIntegrationManagerResponseHandlers!=null){
  1028.                 GestoreHandlers.integrationManagerResponseHandlers = new IntegrationManagerResponseHandler[GestoreHandlers.tipiIntegrationManagerResponseHandlers.length];
  1029.                 for(int i=0; i<GestoreHandlers.tipiIntegrationManagerResponseHandlers.length; i++){
  1030.                     try{
  1031.                         String tipo=GestoreHandlers.tipiIntegrationManagerResponseHandlers[i];
  1032.                         GestoreHandlers.integrationManagerResponseHandlers[i] = (IntegrationManagerResponseHandler) pluginLoader.newIntegrationManagerResponseHandler(tipo);
  1033.                         if(printInfo)
  1034.                             logConsoleInit.info("IntegrationManagerResponseHandler di tipo ["+tipo+"] correttamente inizializzato.");
  1035.                     }catch(Throwable e){
  1036.                         if(msgDiag!=null) {
  1037.                             msgDiag.logErroreGenerico(e, "Inizializzazione IntegrationManagerResponseHandler ["+GestoreHandlers.tipiIntegrationManagerResponseHandlers[i]+"]");
  1038.                         }
  1039.                         else if(logCore!=null) {
  1040.                             logCore.error("Inizializzazione IntegrationManagerResponseHandler ["+GestoreHandlers.tipiIntegrationManagerResponseHandlers[i]+"]", e);
  1041.                         }
  1042.                     }
  1043.                 }
  1044.                 GestoreHandlers.integrationManagerResponseHandlers = reorder(GestoreHandlers.integrationManagerResponseHandlers, new IntegrationManagerResponseHandler[1]);
  1045.             }
  1046.             
  1047.         }
  1048.         
  1049.         GestoreHandlers.initialize=true;
  1050.     }
  1051.     
  1052.     private static String [] _mergeTipi(String [] fromProperties, List<String> fromConfig) {
  1053.         List<String> merge = new ArrayList<>();
  1054.         if(fromProperties!=null && fromProperties.length>0) {
  1055.             for (int i = 0; i < fromProperties.length; i++) {
  1056.                 merge.add(fromProperties[i]);
  1057.             }
  1058.         }
  1059.         if(fromConfig!=null && !fromConfig.isEmpty()) {
  1060.             for (int i = 0; i < fromConfig.size(); i++) {
  1061.                 merge.add(fromConfig.get(i));
  1062.             }
  1063.         }
  1064.         if(!merge.isEmpty()) {
  1065.             return merge.toArray(new String[merge.size()]);
  1066.         }
  1067.         return null;
  1068.     }
  1069.     
  1070.     private static final boolean printOrderInfo = false;
  1071.     private static <T> T[] reorder(T [] handlers, T[] bufferReturn){
  1072.         if(handlers!=null && handlers.length>0){
  1073.             
  1074.             List<String> handlerPositionHeadId = new ArrayList<>();
  1075.             Map<String,T> handlerPositionHeadMap = new HashMap<String,T>();
  1076.             
  1077.             List<String> handlerPositionTailId = new ArrayList<>();
  1078.             Map<String,T> handlerPositionTailMap = new HashMap<String,T>();
  1079.             
  1080.             List<T> handlerPositionMiddle = new ArrayList<T>();
  1081.             
  1082.             if(printOrderInfo){
  1083.                 System.out.println("================== "+handlers.getClass().getName()+" =====================");
  1084.                 System.out.println("PRE ORDER:");
  1085.             }
  1086.             for(int i=0; i<handlers.length; i++){
  1087.                 
  1088.                 if(handlers[i]==null) {
  1089.                     continue;
  1090.                 }
  1091.                 
  1092.                 boolean position = false;
  1093.                 if(handlers[i] instanceof PositionHandler){
  1094.                     PositionHandler p = (PositionHandler) handlers[i];
  1095.                     if(p.getIdPosition()!=null){
  1096.                         if(p.isHeadHandler()){
  1097.                             handlerPositionHeadId.add(p.getIdPosition());
  1098.                             handlerPositionHeadMap.put(p.getIdPosition(), handlers[i]);
  1099.                         }
  1100.                         else{
  1101.                             handlerPositionTailId.add(p.getIdPosition());
  1102.                             handlerPositionTailMap.put(p.getIdPosition(), handlers[i]);
  1103.                         }
  1104.                         position = true;
  1105.                     }
  1106.                 }
  1107.                 if(position==false){
  1108.                     handlerPositionMiddle.add(handlers[i]);
  1109.                 }
  1110.                 
  1111.                 if(printOrderInfo){
  1112.                     System.out.println("\t(Pos:"+position+")["+handlers[i].getClass().getName()+"]");
  1113.                 }
  1114.             }
  1115.             
  1116.             // reorder
  1117.             List<T> orderedList = new ArrayList<T>();
  1118.             
  1119.             if(handlerPositionHeadId.size()>0){
  1120.                 Collections.sort(handlerPositionHeadId);
  1121.                 for (String positionId : handlerPositionHeadId) {
  1122.                     orderedList.add(handlerPositionHeadMap.get(positionId));
  1123.                 }
  1124.             }
  1125.             
  1126.             if(handlerPositionMiddle.size()>0){
  1127.                 for (T t : handlerPositionMiddle) {
  1128.                     orderedList.add(t);
  1129.                 }
  1130.             }
  1131.             
  1132.             if(handlerPositionTailId.size()>0){
  1133.                 Collections.sort(handlerPositionTailId);
  1134.                 for (String positionId : handlerPositionTailId) {
  1135.                     orderedList.add(handlerPositionTailMap.get(positionId));
  1136.                 }
  1137.             }
  1138.             
  1139.             if(orderedList!=null && !orderedList.isEmpty()) {
  1140.                 if(printOrderInfo){
  1141.                     System.out.println("POST ORDER:");
  1142.                     for (T t : orderedList) {
  1143.                         System.out.println("\t["+t.getClass().getName()+"]");
  1144.                     }
  1145.                 }
  1146.                 
  1147.                 return (T[]) orderedList.toArray(bufferReturn);
  1148.             }
  1149.             else {
  1150.                 return null;
  1151.             }
  1152.         }
  1153.         else{
  1154.             return null;
  1155.         }
  1156.     }
  1157.     
  1158.     @SuppressWarnings("unchecked")
  1159.     private static <T> List<Object[]> merge(T [] handlers1, String [] tipiHandlers1, 
  1160.             T [] handlers2, String [] tipiHandlers2, T[] bufferReturn){
  1161.         List<Object[]> lists = new ArrayList<>();
  1162.         if(handlers1==null || handlers1.length<=0) {
  1163.             lists.add(handlers2);
  1164.             lists.add(tipiHandlers2);
  1165.             return lists;
  1166.         }
  1167.         if(handlers2==null || handlers2.length<=0) {
  1168.             lists.add(handlers1);
  1169.             lists.add(tipiHandlers1);
  1170.             return lists;
  1171.         }
  1172.         
  1173.         List<T> listUnsorted = new ArrayList<>();
  1174.         for (int i = 0; i < handlers1.length; i++) {
  1175.             listUnsorted.add(handlers1[i]);
  1176.         }
  1177.         for (int i = 0; i < handlers2.length; i++) {
  1178.             listUnsorted.add(handlers2[i]);
  1179.         }
  1180.         T [] sorted = reorder((T[])listUnsorted.toArray(), bufferReturn);
  1181.         if(sorted!=null) {
  1182.             lists.add(sorted);
  1183.             
  1184.             List<String> listSortedType = new ArrayList<>();
  1185.             for (int i = 0; i < sorted.length; i++) {
  1186.                 T sortHandler = sorted[i];
  1187.                 boolean found = false;
  1188.                 for (int j = 0; j < handlers1.length; j++) {
  1189.                     String sortHandlerClassName = sortHandler.getClass().getName();
  1190.                     if(sortHandlerClassName.equals(handlers1[j].getClass().getName())) {
  1191.                         listSortedType.add(tipiHandlers1[j]);
  1192.                         found = true;
  1193.                         break;
  1194.                     }
  1195.                 }
  1196.                 if(!found) {
  1197.                     for (int j = 0; j < handlers2.length; j++) {
  1198.                         String sortHandlerClassName = sortHandler.getClass().getName();
  1199.                         if(sortHandlerClassName.equals(handlers2[j].getClass().getName())) {
  1200.                             listSortedType.add(tipiHandlers2[j]);
  1201.                             found = true;
  1202.                             break;
  1203.                         }
  1204.                     }
  1205.                 }
  1206.                 if(!found) {
  1207.                     throw new RuntimeException("Errore inatteso durante la gestione dell'handler: "+sortHandler.getClass().getName());
  1208.                 }
  1209.             }
  1210.             lists.add(listSortedType.toArray());
  1211.         }
  1212.         
  1213.         return lists;
  1214.         
  1215.     }
  1216.     
  1217.     
  1218.     private static String[] updateNotifierCallback(String [] tipi) {
  1219.         String notifierInputStreamCallback = null;
  1220.         try{
  1221.             if(properties.isNotifierInputStreamEnabled()) {
  1222.                 notifierInputStreamCallback = properties.getNotifierInputStreamCallback();
  1223.             }
  1224.         }catch(Throwable e){}
  1225.         if(notifierInputStreamCallback!=null){
  1226.             List<String> list = new ArrayList<>();
  1227.             list.add(NotifierConstants.TIPO_NOTIFIER);
  1228.             if(tipi!=null){
  1229.                 for (int i = 0; i < tipi.length; i++) {
  1230.                     list.add(tipi[i]);
  1231.                 }
  1232.             }
  1233.             return list.toArray(new String[1]);
  1234.         }
  1235.         else{
  1236.             return tipi;
  1237.         }
  1238.     }   
  1239.     
  1240.     private static void emitDiagnosticInvokeHandlerStart(Object object, MsgDiagnostico msgDiag,Logger log){
  1241.         try{
  1242.             if(object!=null && msgDiag!=null){
  1243.                 msgDiag.mediumDebug("["+object.getClass().getName()+"] invocazione in corso");
  1244.             }
  1245.         }catch(Throwable t){
  1246.             if(log!=null){
  1247.                 log.error("Errore durante l'emissione del diagnostico: "+t.getMessage(),t);
  1248.             }
  1249.         }
  1250.     }
  1251.     private static void emitDiagnosticInvokeHandlerEnd(Object object, MsgDiagnostico msgDiag,Logger log){
  1252.         try{
  1253.             if(object!=null && msgDiag!=null){
  1254.                 msgDiag.mediumDebug("["+object.getClass().getName()+"] invocazione terminata");
  1255.             }
  1256.         }catch(Throwable t){
  1257.             if(log!=null){
  1258.                 log.error("Errore durante l'emissione del diagnostico: "+t.getMessage(),t);
  1259.             }
  1260.         }
  1261.     }
  1262.     
  1263.     public static void init(InitContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  1264.         
  1265.         if(GestoreHandlers.initialize==false){
  1266.             GestoreHandlers.initialize(msgDiag,log,null);
  1267.         }
  1268.         
  1269.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  1270.             List<Object[]> list =  merge(GestoreHandlers.initHandlersBuiltIn, GestoreHandlers.tipiInitHandlersBuiltIn,
  1271.                     GestoreHandlers.initHandlers, GestoreHandlers.tipiInitHandlers, new InitHandler [1]);
  1272.             InitHandler [] handlers = (InitHandler []) list.get(0);
  1273.             String [] tipiHandlers = toStringArray(list.get(1));
  1274.             _initHandler(context, msgDiag, log, handlers, tipiHandlers, "InitHandler");
  1275.         }
  1276.         else {
  1277.             _initHandler(context, msgDiag, log, GestoreHandlers.initHandlersBuiltIn, GestoreHandlers.tipiInitHandlersBuiltIn, "InitHandler");
  1278.             _initHandler(context, msgDiag, log, GestoreHandlers.initHandlers, GestoreHandlers.tipiInitHandlers, "InitHandler");
  1279.         }
  1280.         
  1281.     }
  1282.     private static void _initHandler(InitContext context,MsgDiagnostico msgDiag,Logger log, InitHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  1283.         if(handlers!=null){
  1284.             for(int i=0; i<handlers.length; i++){
  1285.                 try{
  1286.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  1287.                     handlers[i].invoke(context);
  1288.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  1289.                 }catch(Throwable e){
  1290.                     
  1291.                     if(log!=null){
  1292.                         log.error(name+" ["+tipiHandlers[i]+"] (class:"+handlers[i].getClass().getName()+")",e);
  1293.                     }
  1294.                     
  1295.                     // Sollevo l'eccezione
  1296.                     HandlerException ex = new HandlerException(e.getMessage(),e);
  1297.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  1298.                     throw ex;
  1299.                 }
  1300.             }
  1301.         }
  1302.     }
  1303.     
  1304.     public static void exit(ExitContext context){
  1305.         
  1306.         Logger log = null;
  1307.         if(context!=null){
  1308.             if(context.getLogCore()!=null){
  1309.                 log = context.getLogCore();
  1310.             }else{
  1311.                 log = context.getLogConsole();
  1312.             }
  1313.         }
  1314.         
  1315.         if(GestoreHandlers.initialize){ 
  1316.             
  1317.             // inizializzati cmq dall'init
  1318.             
  1319.             if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  1320.                 List<Object[]> list =  merge(GestoreHandlers.exitHandlersBuiltIn, GestoreHandlers.tipiExitHandlersBuiltIn,
  1321.                         GestoreHandlers.exitHandlers, GestoreHandlers.tipiExitHandlers, new ExitHandler [1]);
  1322.                 ExitHandler [] handlers = (ExitHandler []) list.get(0);
  1323.                 String [] tipiHandlers = toStringArray(list.get(1));
  1324.                 _exitHandler(context, log, handlers, tipiHandlers, "ExitHandler");
  1325.             }
  1326.             else {
  1327.                 _exitHandler(context, log, GestoreHandlers.exitHandlersBuiltIn, GestoreHandlers.tipiExitHandlersBuiltIn, "ExitHandler");
  1328.                 _exitHandler(context, log, GestoreHandlers.exitHandlers, GestoreHandlers.tipiExitHandlers, "ExitHandler");
  1329.             }
  1330.         }
  1331.     }
  1332.     private static void _exitHandler(ExitContext context,Logger log, ExitHandler [] handlers, String [] tipiHandlers, String name) {
  1333.         if(handlers!=null){
  1334.             for(int i=0; i<handlers.length; i++){
  1335.                 try{
  1336.                     handlers[i].invoke(context);
  1337.                 }catch(Throwable e){
  1338.                     // Gli handler di tipo exit non dovrebbero sollevare una eccezione.
  1339.                     // Eventualmento loggo l'errore
  1340.                     if(log!=null){
  1341.                         log.error(name+" ["+tipiHandlers[i]+"] (class:"+handlers[i].getClass().getName()+")",e);
  1342.                     }
  1343.                 }
  1344.             }
  1345.         }
  1346.     }
  1347.     
  1348.     
  1349.     public static void preInRequest(PreInAcceptRequestContext context,Logger logCore,Logger log) {
  1350.         _engine_preInRequest(null, context, null, logCore, log);
  1351.     }
  1352.     public static void emitDiagnostic(MsgDiagnostico msgDiag, PreInAcceptRequestContext context, PdDContext pddContext,Logger logCore,Logger log) {
  1353.         _engine_preInRequest(msgDiag, context, pddContext, logCore, log);
  1354.     }
  1355.     public static void _engine_preInRequest(MsgDiagnostico msgDiag, PreInAcceptRequestContext context, PdDContext pddContext,Logger logCore,Logger log) {
  1356.         
  1357.         if(!GestoreHandlers.initialize){
  1358.             GestoreHandlers.initialize(logCore,log);
  1359.         }
  1360.         
  1361.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  1362.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(msgDiag, context, pddContext,GestoreHandlers.preInRequestHandlers, GestoreHandlers.tipiPreInRequestHandlers, log);
  1363.         PreInRequestHandler [] preInRequestHandlersUsers = (PreInRequestHandler []) mergeWithImplementation.get(0);
  1364.         String [] tipiPreInRequestHandlersUsers = (String []) mergeWithImplementation.get(1);
  1365.         
  1366.         // gestisco handler built-in e user
  1367.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  1368.             List<Object[]> list =  merge(GestoreHandlers.preInRequestHandlersBuiltIn, GestoreHandlers.tipiPreInRequestHandlersBuiltIn,
  1369.                     preInRequestHandlersUsers, tipiPreInRequestHandlersUsers, new PreInRequestHandler [1]);
  1370.             PreInRequestHandler [] handlers = (PreInRequestHandler []) list.get(0);
  1371.             String [] tipiHandlers = toStringArray(list.get(1));
  1372.             _preInRequestHandler(msgDiag, context, pddContext, log, handlers, tipiHandlers, "PreInRequestHandler");
  1373.         }
  1374.         else {
  1375.             _preInRequestHandler(msgDiag, context, pddContext, log, GestoreHandlers.preInRequestHandlersBuiltIn, GestoreHandlers.tipiPreInRequestHandlersBuiltIn, "PreInRequestHandler");
  1376.             _preInRequestHandler(msgDiag, context, pddContext, log, preInRequestHandlersUsers, tipiPreInRequestHandlersUsers, "PreInRequestHandler");
  1377.         }
  1378.         
  1379.     }
  1380.     private static List<Object[]> mergeWithImplementationEngine(MsgDiagnostico msgDiag, PreInAcceptRequestContext context, PdDContext pddContext,
  1381.             PreInRequestHandler [] preInRequestHandlers,String [] tipiPreInRequestHandlers,
  1382.             Logger log) {
  1383.         List<Object[]> mergeList = null;
  1384.         try{
  1385.             List<String> tipiPorta=null;
  1386.             if(context!=null && context.getRequestInfo()!=null && context.getRequestInfo().getProtocolContext()!=null &&
  1387.                     context.getRequestInfo().getProtocolContext().getInterfaceName()!=null) {
  1388.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance();
  1389.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  1390.                     IDPortaDelegata idPD = new IDPortaDelegata();
  1391.                     idPD.setNome(context.getRequestInfo().getProtocolContext().getInterfaceName());
  1392.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, context.getRequestInfo());
  1393.                     tipiPorta=configurazionePdDManager.getPreInRequestHandlers(pd);
  1394.                     /**System.out.println("PreInRequestContext find PD '"+pd.getNome()+"'");*/
  1395.                 }
  1396.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  1397.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1398.                     idPA.setNome(context.getRequestInfo().getProtocolContext().getInterfaceName());
  1399.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, context.getRequestInfo());
  1400.                     tipiPorta=configurazionePdDManager.getPreInRequestHandlers(pa);
  1401.                     /**System.out.println("PreInRequestContext find PA '"+pa.getNome()+"'");*/
  1402.                 }
  1403.             }
  1404.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  1405.                 List<PreInRequestHandler> listHandler = new ArrayList<>();
  1406.                 List<String> listTipi = new ArrayList<>();
  1407.                 if(preInRequestHandlers!=null && preInRequestHandlers.length>0) {
  1408.                     for (int i = 0; i < preInRequestHandlers.length; i++) {
  1409.                         listHandler.add(preInRequestHandlers[i]);
  1410.                         listTipi.add(tipiPreInRequestHandlers[i]);
  1411.                     }
  1412.                 }
  1413.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1414.                 for (String tipoPorta : tipiPorta) {
  1415.                     if(!listTipi.contains(tipoPorta)) {
  1416.                         try {
  1417.                             PreInRequestHandler handler = pluginLoader.newPreInRequestHandler(tipoPorta);
  1418.                             listHandler.add(handler);
  1419.                             listTipi.add(tipoPorta);
  1420.                         }catch(Throwable t) {
  1421.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  1422.                             // Sollevo l'eccezione
  1423.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  1424.                             ex.setIdentitaHandler("PreInRequestHandler"+" ["+tipoPorta+"]");
  1425.                             throw ex;
  1426.                         }
  1427.                     }
  1428.                 }
  1429.                 if(!listHandler.isEmpty()) {
  1430.                     mergeList = new ArrayList<>();
  1431.                     mergeList.add(listHandler.toArray(new PreInRequestHandler[listHandler.size()]));
  1432.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  1433.                 }
  1434.             }
  1435.         }catch(Throwable t) {
  1436.             log.error(t.getMessage(),t);
  1437.         }
  1438.         if(mergeList==null) {
  1439.             mergeList = new ArrayList<>();
  1440.             mergeList.add(preInRequestHandlers);
  1441.             mergeList.add(tipiPreInRequestHandlers);
  1442.         }
  1443.         return mergeList;
  1444.     }
  1445.     private static void _preInRequestHandler(MsgDiagnostico msgDiag, PreInAcceptRequestContext context, PdDContext pddContext,Logger log,
  1446.             PreInRequestHandler [] handlers, String [] tipiHandlers, String name) {
  1447.         if(handlers!=null){
  1448.             for(int i=0; i<handlers.length; i++){
  1449.                 try{
  1450.                     if(msgDiag!=null) {
  1451.                         handlers[i].emitDiagnostic(msgDiag, context, pddContext);
  1452.                     }
  1453.                     else {
  1454.                         emitDiagnosticInvokeHandlerStart(handlers[i], null, log);
  1455.                         handlers[i].invoke(context);
  1456.                         emitDiagnosticInvokeHandlerEnd(handlers[i], null, log);
  1457.                     }
  1458.                 }catch(Throwable e){
  1459.                     // Sollevo l'eccezione
  1460.                     /*HandlerException ex = null;
  1461.                     if(e instanceof HandlerException){
  1462.                         ex = (HandlerException) e;
  1463.                     }else{
  1464.                         ex = new HandlerException(e.getMessage(),e);
  1465.                     }
  1466.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  1467.                     throw ex;
  1468.                     */
  1469.                     // L'handler invocato con il contesto 'PreInAcceptRequestContext' non dovrebbe sollevare una eccezione
  1470.                     // Eventualmento loggo l'errore
  1471.                     if(log!=null){
  1472.                         log.error(name+" ["+tipiHandlers[i]+"] 'PreInAcceptRequestContext' (class:"+handlers[i].getClass().getName()+")",e);
  1473.                     }
  1474.                 }
  1475.             }
  1476.         }
  1477.     }
  1478.     
  1479.     public static void preInRequest(PreInRequestContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  1480.         
  1481.         if(!GestoreHandlers.initialize){
  1482.             GestoreHandlers.initialize(msgDiag,log,null);
  1483.         }
  1484.         
  1485.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  1486.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.preInRequestHandlers, GestoreHandlers.tipiPreInRequestHandlers, log);
  1487.         PreInRequestHandler [] preInRequestHandlersUsers = (PreInRequestHandler []) mergeWithImplementation.get(0);
  1488.         String [] tipiPreInRequestHandlersUsers = (String []) mergeWithImplementation.get(1);
  1489.         
  1490.         // gestisco handler built-in e user
  1491.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  1492.             List<Object[]> list =  merge(GestoreHandlers.preInRequestHandlersBuiltIn, GestoreHandlers.tipiPreInRequestHandlersBuiltIn,
  1493.                     preInRequestHandlersUsers, tipiPreInRequestHandlersUsers, new PreInRequestHandler [1]);
  1494.             PreInRequestHandler [] handlers = (PreInRequestHandler []) list.get(0);
  1495.             String [] tipiHandlers = toStringArray(list.get(1));
  1496.             _preInRequestHandler(context, msgDiag, log, handlers, tipiHandlers, "PreInRequestHandler");
  1497.         }
  1498.         else {
  1499.             _preInRequestHandler(context, msgDiag, log, GestoreHandlers.preInRequestHandlersBuiltIn, GestoreHandlers.tipiPreInRequestHandlersBuiltIn, "PreInRequestHandler");
  1500.             _preInRequestHandler(context, msgDiag, log, preInRequestHandlersUsers, tipiPreInRequestHandlersUsers, "PreInRequestHandler");
  1501.         }
  1502.         
  1503.     }
  1504.     private static List<Object[]> mergeWithImplementationEngine(PreInRequestContext context,PreInRequestHandler [] preInRequestHandlers,String [] tipiPreInRequestHandlers,
  1505.             Logger log) {
  1506.         List<Object[]> mergeList = null;
  1507.         try{
  1508.             List<String> tipiPorta=null;
  1509.             if(context!=null && context.getRequestInfo()!=null && context.getRequestInfo().getProtocolContext()!=null &&
  1510.                     context.getRequestInfo().getProtocolContext().getInterfaceName()!=null) {
  1511.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance();
  1512.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  1513.                     IDPortaDelegata idPD = new IDPortaDelegata();
  1514.                     idPD.setNome(context.getRequestInfo().getProtocolContext().getInterfaceName());
  1515.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, context.getRequestInfo());
  1516.                     tipiPorta=configurazionePdDManager.getPreInRequestHandlers(pd);
  1517.                     /**System.out.println("PreInRequestContext find PD '"+pd.getNome()+"'");*/
  1518.                 }
  1519.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  1520.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1521.                     idPA.setNome(context.getRequestInfo().getProtocolContext().getInterfaceName());
  1522.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, context.getRequestInfo());
  1523.                     tipiPorta=configurazionePdDManager.getPreInRequestHandlers(pa);
  1524.                     /**System.out.println("PreInRequestContext find PA '"+pa.getNome()+"'");*/
  1525.                 }
  1526.             }
  1527.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  1528.                 List<PreInRequestHandler> listHandler = new ArrayList<>();
  1529.                 List<String> listTipi = new ArrayList<>();
  1530.                 if(preInRequestHandlers!=null && preInRequestHandlers.length>0) {
  1531.                     for (int i = 0; i < preInRequestHandlers.length; i++) {
  1532.                         listHandler.add(preInRequestHandlers[i]);
  1533.                         listTipi.add(tipiPreInRequestHandlers[i]);
  1534.                     }
  1535.                 }
  1536.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1537.                 for (String tipoPorta : tipiPorta) {
  1538.                     if(!listTipi.contains(tipoPorta)) {
  1539.                         try {
  1540.                             PreInRequestHandler handler = pluginLoader.newPreInRequestHandler(tipoPorta);
  1541.                             listHandler.add(handler);
  1542.                             listTipi.add(tipoPorta);
  1543.                         }catch(Throwable t) {
  1544.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  1545.                             // Sollevo l'eccezione
  1546.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  1547.                             ex.setIdentitaHandler("PreInRequestHandler"+" ["+tipoPorta+"]");
  1548.                             throw ex;
  1549.                         }
  1550.                     }
  1551.                 }
  1552.                 if(!listHandler.isEmpty()) {
  1553.                     mergeList = new ArrayList<>();
  1554.                     mergeList.add(listHandler.toArray(new PreInRequestHandler[listHandler.size()]));
  1555.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  1556.                 }
  1557.             }
  1558.         }catch(Throwable t) {
  1559.             log.error(t.getMessage(),t);
  1560.         }
  1561.         if(mergeList==null) {
  1562.             mergeList = new ArrayList<>();
  1563.             mergeList.add(preInRequestHandlers);
  1564.             mergeList.add(tipiPreInRequestHandlers);
  1565.         }
  1566.         return mergeList;
  1567.     }
  1568.     private static void _preInRequestHandler(PreInRequestContext context,MsgDiagnostico msgDiag,Logger log, PreInRequestHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  1569.         if(handlers!=null){
  1570.             for(int i=0; i<handlers.length; i++){
  1571.                 try{
  1572.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  1573.                     handlers[i].invoke(context);
  1574.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  1575.                 }catch(Throwable e){
  1576.                     // Sollevo l'eccezione
  1577.                     HandlerException ex = null;
  1578.                     if(e instanceof HandlerException){
  1579.                         ex = (HandlerException) e;
  1580.                     }else{
  1581.                         ex = new HandlerException(e.getMessage(),e);
  1582.                     }
  1583.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  1584.                     throw ex;
  1585.                 }
  1586.             }
  1587.         }
  1588.     }
  1589.     
  1590.     public static void inRequest(InRequestContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  1591.         
  1592.         if(!GestoreHandlers.initialize){
  1593.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  1594.         }
  1595.     
  1596.         if(context.getDataElaborazioneMessaggio()==null){
  1597.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  1598.         }
  1599.         
  1600.         // genero date casuali 
  1601.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1602.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  1603.         }
  1604.         
  1605.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  1606.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.inRequestHandlers, GestoreHandlers.tipiInRequestHandlers, log);
  1607.         InRequestHandler [] inRequestHandlersUsers = (InRequestHandler []) mergeWithImplementation.get(0);
  1608.         String [] tipiInRequestHandlersUsers = (String []) mergeWithImplementation.get(1);
  1609.         
  1610.         // gestisco handler built-in e user
  1611.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  1612.             List<Object[]> list =  merge(GestoreHandlers.inRequestHandlersBuiltIn, GestoreHandlers.tipiInRequestHandlersBuiltIn,
  1613.                     inRequestHandlersUsers, tipiInRequestHandlersUsers, new InRequestHandler [1]);
  1614.             InRequestHandler [] handlers = (InRequestHandler []) list.get(0);
  1615.             String [] tipiHandlers = toStringArray(list.get(1));
  1616.             _inRequestHandler(context, msgDiag, log, handlers, tipiHandlers, "InRequestHandler");
  1617.         }
  1618.         else {
  1619.             _inRequestHandler(context, msgDiag, log, GestoreHandlers.inRequestHandlersBuiltIn, GestoreHandlers.tipiInRequestHandlersBuiltIn, "InRequestHandler");
  1620.             _inRequestHandler(context, msgDiag, log, inRequestHandlersUsers, tipiInRequestHandlersUsers, "InRequestHandler");
  1621.         }
  1622.         
  1623.     }
  1624.     private static List<Object[]> mergeWithImplementationEngine(InRequestContext context,InRequestHandler [] inRequestHandlers,String [] tipiInRequestHandlers,
  1625.             Logger log) {
  1626.         List<Object[]> mergeList = null;
  1627.         try{
  1628.             List<String> tipiPorta=null;
  1629.             if(context!=null) {
  1630.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  1631.                 
  1632.                 RequestInfo requestInfo = null;
  1633.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  1634.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  1635.                 }
  1636.                 
  1637.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  1638.                     IDPortaDelegata idPD = null;
  1639.                     if(context.getConnettore()!=null && context.getConnettore().getUrlProtocolContext()!=null &&
  1640.                             context.getConnettore().getUrlProtocolContext().getInterfaceName()!=null) {
  1641.                         idPD = new IDPortaDelegata();
  1642.                         idPD.setNome(context.getConnettore().getUrlProtocolContext().getInterfaceName());
  1643.                     }
  1644.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1645.                         idPD = new IDPortaDelegata();
  1646.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  1647.                     }
  1648.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  1649.                     tipiPorta=configurazionePdDManager.getInRequestHandlers(pd);
  1650.                     /**System.out.println("InRequestContext find PD '"+pd.getNome()+"'");*/
  1651.                 }
  1652.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  1653.                     IDPortaApplicativa idPA = null;
  1654.                     if(context.getConnettore()!=null && context.getConnettore().getUrlProtocolContext()!=null &&
  1655.                             context.getConnettore().getUrlProtocolContext().getInterfaceName()!=null) {
  1656.                         idPA = new IDPortaApplicativa();
  1657.                         idPA.setNome(context.getConnettore().getUrlProtocolContext().getInterfaceName());
  1658.                     }
  1659.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1660.                         idPA = new IDPortaApplicativa();
  1661.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  1662.                     }
  1663.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  1664.                     tipiPorta=configurazionePdDManager.getInRequestHandlers(pa);
  1665.                     /**System.out.println("InRequestContext find PA '"+pa.getNome()+"'");*/
  1666.                 }
  1667.             }
  1668.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  1669.                 List<InRequestHandler> listHandler = new ArrayList<>();
  1670.                 List<String> listTipi = new ArrayList<>();
  1671.                 if(inRequestHandlers!=null && inRequestHandlers.length>0) {
  1672.                     for (int i = 0; i < inRequestHandlers.length; i++) {
  1673.                         listHandler.add(inRequestHandlers[i]);
  1674.                         listTipi.add(tipiInRequestHandlers[i]);
  1675.                     }
  1676.                 }
  1677.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1678.                 for (String tipoPorta : tipiPorta) {
  1679.                     if(!listTipi.contains(tipoPorta)) {
  1680.                         try {
  1681.                             InRequestHandler handler = pluginLoader.newInRequestHandler(tipoPorta);
  1682.                             listHandler.add(handler);
  1683.                             listTipi.add(tipoPorta);
  1684.                         }catch(Throwable t) {
  1685.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  1686.                             // Sollevo l'eccezione
  1687.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  1688.                             ex.setIdentitaHandler("InRequestHandler"+" ["+tipoPorta+"]");
  1689.                             throw ex;
  1690.                         }
  1691.                     }
  1692.                 }
  1693.                 if(!listHandler.isEmpty()) {
  1694.                     mergeList = new ArrayList<>();
  1695.                     mergeList.add(listHandler.toArray(new InRequestHandler[listHandler.size()]));
  1696.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  1697.                 }
  1698.             }
  1699.         }catch(Throwable t) {
  1700.             log.error(t.getMessage(),t);
  1701.         }
  1702.         if(mergeList==null) {
  1703.             mergeList = new ArrayList<>();
  1704.             mergeList.add(inRequestHandlers);
  1705.             mergeList.add(tipiInRequestHandlers);
  1706.         }
  1707.         return mergeList;
  1708.     }
  1709.     private static void _inRequestHandler(InRequestContext context,MsgDiagnostico msgDiag,Logger log, InRequestHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  1710.         if(handlers!=null){
  1711.             for(int i=0; i<handlers.length; i++){
  1712.                 try{
  1713.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  1714.                     handlers[i].invoke(context);
  1715.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  1716.                 }catch(Throwable e){
  1717.                     // Sollevo l'eccezione
  1718.                     HandlerException ex = null;
  1719.                     if(e instanceof HandlerException){
  1720.                         ex = (HandlerException) e;
  1721.                     }else{
  1722.                         ex = new HandlerException(e.getMessage(),e);
  1723.                     }
  1724.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  1725.                     throw ex;
  1726.                 }
  1727.             }
  1728.         }
  1729.     }
  1730.     
  1731.     public static void inRequestProtocol(InRequestProtocolContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  1732.         
  1733.         if(!GestoreHandlers.initialize){
  1734.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  1735.         }
  1736.     
  1737.         if(context.getDataElaborazioneMessaggio()==null){
  1738.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  1739.         }
  1740.         
  1741.         // genero date casuali 
  1742.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1743.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  1744.         }
  1745.         
  1746.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  1747.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.inRequestProtocolHandlers, GestoreHandlers.tipiInRequestProtocolHandlers, log);
  1748.         InRequestProtocolHandler [] inRequestProtocolHandlersUsers = (InRequestProtocolHandler []) mergeWithImplementation.get(0);
  1749.         String [] tipiInRequestProtocolHandlersUsers = (String []) mergeWithImplementation.get(1);
  1750.         
  1751.         // gestisco handler built-in e user
  1752.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  1753.             List<Object[]> list =  merge(GestoreHandlers.inRequestProtocolHandlersBuiltIn, GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn,
  1754.                     inRequestProtocolHandlersUsers, tipiInRequestProtocolHandlersUsers, new InRequestProtocolHandler [1]);
  1755.             InRequestProtocolHandler [] handlers = (InRequestProtocolHandler []) list.get(0);
  1756.             String [] tipiHandlers = toStringArray(list.get(1));
  1757.             _inRequestProtocolHandler(context, msgDiag, log, handlers, tipiHandlers, "InRequestProtocolHandler");
  1758.         }
  1759.         else {
  1760.             _inRequestProtocolHandler(context, msgDiag, log, GestoreHandlers.inRequestProtocolHandlersBuiltIn, GestoreHandlers.tipiInRequestProtocolHandlersBuiltIn, "InRequestProtocolHandler");
  1761.             _inRequestProtocolHandler(context, msgDiag, log, inRequestProtocolHandlersUsers, tipiInRequestProtocolHandlersUsers, "InRequestProtocolHandler");
  1762.         }
  1763.         
  1764.     }
  1765.     private static List<Object[]> mergeWithImplementationEngine(InRequestProtocolContext context,InRequestProtocolHandler [] intRequestProtocolHandlers,String [] tipiInRequestProtocolHandlers,
  1766.             Logger log) {
  1767.         List<Object[]> mergeList = null;
  1768.         try{
  1769.             List<String> tipiPorta=null;
  1770.             if(context!=null) {
  1771.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  1772.                 
  1773.                 RequestInfo requestInfo = null;
  1774.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  1775.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  1776.                 }
  1777.                 
  1778.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  1779.                     IDPortaDelegata idPD = null;
  1780.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null) {
  1781.                         idPD = context.getIntegrazione().getIdPD();
  1782.                     }
  1783.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1784.                         idPD = new IDPortaDelegata();
  1785.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  1786.                     }
  1787.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  1788.                     tipiPorta=configurazionePdDManager.getInRequestProtocolHandlers(pd);
  1789.                     /**System.out.println("InRequestProtocolContext find PD '"+pd.getNome()+"'");*/
  1790.                 }
  1791.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  1792.                     IDPortaApplicativa idPA = null;
  1793.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null) {
  1794.                         idPA = context.getIntegrazione().getIdPA();
  1795.                     }
  1796.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1797.                         idPA = new IDPortaApplicativa();
  1798.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  1799.                     }
  1800.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  1801.                     tipiPorta=configurazionePdDManager.getInRequestProtocolHandlers(pa);
  1802.                     /**System.out.println("InRequestProtocolContext find PA '"+pa.getNome()+"'");*/
  1803.                 }
  1804.             }
  1805.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  1806.                 List<InRequestProtocolHandler> listHandler = new ArrayList<>();
  1807.                 List<String> listTipi = new ArrayList<>();
  1808.                 if(intRequestProtocolHandlers!=null && intRequestProtocolHandlers.length>0) {
  1809.                     for (int i = 0; i < intRequestProtocolHandlers.length; i++) {
  1810.                         listHandler.add(intRequestProtocolHandlers[i]);
  1811.                         listTipi.add(tipiInRequestProtocolHandlers[i]);
  1812.                     }
  1813.                 }
  1814.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1815.                 for (String tipoPorta : tipiPorta) {
  1816.                     if(!listTipi.contains(tipoPorta)) {
  1817.                         try {
  1818.                             InRequestProtocolHandler handler = pluginLoader.newInRequestProtocolHandler(tipoPorta);
  1819.                             listHandler.add(handler);
  1820.                             listTipi.add(tipoPorta);
  1821.                         }catch(Throwable t) {
  1822.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  1823.                             // Sollevo l'eccezione
  1824.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  1825.                             ex.setIdentitaHandler("InRequestProtocolHandler"+" ["+tipoPorta+"]");
  1826.                             throw ex;
  1827.                         }
  1828.                     }
  1829.                 }
  1830.                 if(!listHandler.isEmpty()) {
  1831.                     mergeList = new ArrayList<>();
  1832.                     mergeList.add(listHandler.toArray(new InRequestProtocolHandler[listHandler.size()]));
  1833.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  1834.                 }
  1835.             }
  1836.         }catch(Throwable t) {
  1837.             log.error(t.getMessage(),t);
  1838.         }
  1839.         if(mergeList==null) {
  1840.             mergeList = new ArrayList<>();
  1841.             mergeList.add(intRequestProtocolHandlers);
  1842.             mergeList.add(tipiInRequestProtocolHandlers);
  1843.         }
  1844.         return mergeList;
  1845.     }
  1846.     private static void _inRequestProtocolHandler(InRequestProtocolContext context,MsgDiagnostico msgDiag,Logger log, InRequestProtocolHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  1847.         if(handlers!=null){
  1848.             for(int i=0; i<handlers.length; i++){
  1849.                 try{
  1850.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  1851.                     handlers[i].invoke(context);
  1852.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  1853.                 }catch(Throwable e){
  1854.                     // Sollevo l'eccezione
  1855.                     HandlerException ex = null;
  1856.                     if(e instanceof HandlerException){
  1857.                         ex = (HandlerException) e;
  1858.                     }else{
  1859.                         ex = new HandlerException(e.getMessage(),e);
  1860.                     }
  1861.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  1862.                     throw ex;
  1863.                 }
  1864.             }
  1865.         }
  1866.     }
  1867.     
  1868.     public static void outRequest(OutRequestContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  1869.         
  1870.         if(!GestoreHandlers.initialize){
  1871.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  1872.         }
  1873.     
  1874.         if(context.getDataElaborazioneMessaggio()==null){
  1875.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  1876.         }
  1877.         
  1878.         // genero date casuali 
  1879.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  1880.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  1881.         }
  1882.         
  1883.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  1884.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.outRequestHandlers, GestoreHandlers.tipiOutRequestHandlers, log);
  1885.         OutRequestHandler [] outRequestHandlersUsers = (OutRequestHandler []) mergeWithImplementation.get(0);
  1886.         String [] tipiOutRequestHandlersUsers = (String []) mergeWithImplementation.get(1);
  1887.         
  1888.         // gestisco handler built-in e user
  1889.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  1890.             List<Object[]> list =  merge(GestoreHandlers.outRequestHandlersBuiltIn, GestoreHandlers.tipiOutRequestHandlersBuiltIn,
  1891.                     outRequestHandlersUsers, tipiOutRequestHandlersUsers, new OutRequestHandler [1]);
  1892.             OutRequestHandler [] handlers = (OutRequestHandler []) list.get(0);
  1893.             String [] tipiHandlers = toStringArray(list.get(1));
  1894.             _outRequestHandler(context, msgDiag, log, handlers, tipiHandlers, "OutRequestHandler");
  1895.         }
  1896.         else {
  1897.             _outRequestHandler(context, msgDiag, log, GestoreHandlers.outRequestHandlersBuiltIn, GestoreHandlers.tipiOutRequestHandlersBuiltIn, "OutRequestHandler");
  1898.             _outRequestHandler(context, msgDiag, log, outRequestHandlersUsers, tipiOutRequestHandlersUsers, "OutRequestHandler");
  1899.         }
  1900.         
  1901.     }
  1902.     private static List<Object[]> mergeWithImplementationEngine(OutRequestContext context,OutRequestHandler [] outRequestHandlers,String [] tipiOutRequestHandlers,
  1903.             Logger log) {
  1904.         List<Object[]> mergeList = null;
  1905.         try{
  1906.             List<String> tipiPorta=null;
  1907.             if(context!=null) {
  1908.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  1909.                 
  1910.                 RequestInfo requestInfo = null;
  1911.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  1912.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  1913.                 }
  1914.                 
  1915.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  1916.                     IDPortaDelegata idPD = null;
  1917.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null) {
  1918.                         idPD = context.getIntegrazione().getIdPD();
  1919.                     }
  1920.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1921.                         idPD = new IDPortaDelegata();
  1922.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  1923.                     }
  1924.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  1925.                     tipiPorta=configurazionePdDManager.getOutRequestHandlers(pd);
  1926.                     /**System.out.println("OutRequestContext find PD '"+pd.getNome()+"'");*/
  1927.                 }
  1928.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  1929.                     IDPortaApplicativa idPA = null;
  1930.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null) {
  1931.                         idPA = context.getIntegrazione().getIdPA();
  1932.                     }
  1933.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  1934.                         idPA = new IDPortaApplicativa();
  1935.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  1936.                     }
  1937.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  1938.                     tipiPorta=configurazionePdDManager.getOutRequestHandlers(pa);
  1939.                     /**System.out.println("OutRequestContext find PA '"+pa.getNome()+"'");*/
  1940.                 }
  1941.             }
  1942.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  1943.                 List<OutRequestHandler> listHandler = new ArrayList<>();
  1944.                 List<String> listTipi = new ArrayList<>();
  1945.                 if(outRequestHandlers!=null && outRequestHandlers.length>0) {
  1946.                     for (int i = 0; i < outRequestHandlers.length; i++) {
  1947.                         listHandler.add(outRequestHandlers[i]);
  1948.                         listTipi.add(tipiOutRequestHandlers[i]);
  1949.                     }
  1950.                 }
  1951.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1952.                 for (String tipoPorta : tipiPorta) {
  1953.                     if(!listTipi.contains(tipoPorta)) {
  1954.                         try {
  1955.                             OutRequestHandler handler = pluginLoader.newOutRequestHandler(tipoPorta);
  1956.                             listHandler.add(handler);
  1957.                             listTipi.add(tipoPorta);
  1958.                         }catch(Throwable t) {
  1959.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  1960.                             // Sollevo l'eccezione
  1961.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  1962.                             ex.setIdentitaHandler("OutRequestHandler"+" ["+tipoPorta+"]");
  1963.                             throw ex;
  1964.                         }
  1965.                     }
  1966.                 }
  1967.                 if(!listHandler.isEmpty()) {
  1968.                     mergeList = new ArrayList<>();
  1969.                     mergeList.add(listHandler.toArray(new OutRequestHandler[listHandler.size()]));
  1970.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  1971.                 }
  1972.             }
  1973.         }catch(Throwable t) {
  1974.             log.error(t.getMessage(),t);
  1975.         }
  1976.         if(mergeList==null) {
  1977.             mergeList = new ArrayList<>();
  1978.             mergeList.add(outRequestHandlers);
  1979.             mergeList.add(tipiOutRequestHandlers);
  1980.         }
  1981.         return mergeList;
  1982.     }
  1983.     private static void _outRequestHandler(OutRequestContext context,MsgDiagnostico msgDiag,Logger log, OutRequestHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  1984.         if(handlers!=null){
  1985.             for(int i=0; i<handlers.length; i++){
  1986.                 try{
  1987.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  1988.                     handlers[i].invoke(context);
  1989.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  1990.                 }catch(Throwable e){
  1991.                     // Sollevo l'eccezione
  1992.                     HandlerException ex = null;
  1993.                     if(e instanceof HandlerException){
  1994.                         ex = (HandlerException) e;
  1995.                     }else{
  1996.                         ex = new HandlerException(e.getMessage(),e);
  1997.                     }
  1998.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  1999.                     throw ex;
  2000.                 }
  2001.             }
  2002.         }
  2003.     }
  2004.     
  2005.     public static void postOutRequest(PostOutRequestContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  2006.         
  2007.         if(!GestoreHandlers.initialize){
  2008.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  2009.         }
  2010.     
  2011.         if(context.getDataElaborazioneMessaggio()==null){
  2012.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  2013.         }
  2014.         
  2015.         // genero date casuali 
  2016.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2017.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2018.         }
  2019.         
  2020.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  2021.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.postOutRequestHandlers, GestoreHandlers.tipiPostOutRequestHandlers, log);
  2022.         PostOutRequestHandler [] postOutRequestHandlersUsers = (PostOutRequestHandler []) mergeWithImplementation.get(0);
  2023.         String [] tipiPostOutRequestHandlersUsers = (String []) mergeWithImplementation.get(1);
  2024.         
  2025.         // gestisco handler built-in e user
  2026.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  2027.             List<Object[]> list =  merge(GestoreHandlers.postOutRequestHandlersBuiltIn, GestoreHandlers.tipiPostOutRequestHandlersBuiltIn,
  2028.                     postOutRequestHandlersUsers, tipiPostOutRequestHandlersUsers, new PostOutRequestHandler [1]);
  2029.             PostOutRequestHandler [] handlers = (PostOutRequestHandler []) list.get(0);
  2030.             String [] tipiHandlers = toStringArray(list.get(1));
  2031.             _postOutRequestHandler(context, msgDiag, log, handlers, tipiHandlers, "PostOutRequestHandler");
  2032.         }
  2033.         else {
  2034.             _postOutRequestHandler(context, msgDiag, log, GestoreHandlers.postOutRequestHandlersBuiltIn, GestoreHandlers.tipiPostOutRequestHandlersBuiltIn, "PostOutRequestHandler");
  2035.             _postOutRequestHandler(context, msgDiag, log, postOutRequestHandlersUsers, tipiPostOutRequestHandlersUsers, "PostOutRequestHandler");
  2036.         }
  2037.         
  2038.     }
  2039.     private static List<Object[]> mergeWithImplementationEngine(PostOutRequestContext context,PostOutRequestHandler [] postOutRequestHandlers,String [] tipiPostOutRequestHandlers,
  2040.             Logger log) {
  2041.         List<Object[]> mergeList = null;
  2042.         try{
  2043.             List<String> tipiPorta=null;
  2044.             if(context!=null) {
  2045.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  2046.                 
  2047.                 RequestInfo requestInfo = null;
  2048.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  2049.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  2050.                 }
  2051.                 
  2052.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  2053.                     IDPortaDelegata idPD = null;
  2054.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null) {
  2055.                         idPD = context.getIntegrazione().getIdPD();
  2056.                     }
  2057.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2058.                         idPD = new IDPortaDelegata();
  2059.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2060.                     }
  2061.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  2062.                     tipiPorta=configurazionePdDManager.getPostOutRequestHandlers(pd);
  2063.                     /**System.out.println("PostOutRequestContext find PD '"+pd.getNome()+"'");*/
  2064.                 }
  2065.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  2066.                     IDPortaApplicativa idPA = null;
  2067.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null) {
  2068.                         idPA = context.getIntegrazione().getIdPA();
  2069.                     }
  2070.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2071.                         idPA = new IDPortaApplicativa();
  2072.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2073.                     }
  2074.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  2075.                     tipiPorta=configurazionePdDManager.getPostOutRequestHandlers(pa);
  2076.                     /**System.out.println("PostOutRequestContext find PA '"+pa.getNome()+"'");*/
  2077.                 }
  2078.             }
  2079.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  2080.                 List<PostOutRequestHandler> listHandler = new ArrayList<>();
  2081.                 List<String> listTipi = new ArrayList<>();
  2082.                 if(postOutRequestHandlers!=null && postOutRequestHandlers.length>0) {
  2083.                     for (int i = 0; i < postOutRequestHandlers.length; i++) {
  2084.                         listHandler.add(postOutRequestHandlers[i]);
  2085.                         listTipi.add(tipiPostOutRequestHandlers[i]);
  2086.                     }
  2087.                 }
  2088.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  2089.                 for (String tipoPorta : tipiPorta) {
  2090.                     if(!listTipi.contains(tipoPorta)) {
  2091.                         try {
  2092.                             PostOutRequestHandler handler = pluginLoader.newPostOutRequestHandler(tipoPorta);
  2093.                             listHandler.add(handler);
  2094.                             listTipi.add(tipoPorta);
  2095.                         }catch(Throwable t) {
  2096.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  2097.                             // Sollevo l'eccezione
  2098.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  2099.                             ex.setIdentitaHandler("PostOutRequestHandler"+" ["+tipoPorta+"]");
  2100.                             throw ex;
  2101.                         }
  2102.                     }
  2103.                 }
  2104.                 if(!listHandler.isEmpty()) {
  2105.                     mergeList = new ArrayList<>();
  2106.                     mergeList.add(listHandler.toArray(new PostOutRequestHandler[listHandler.size()]));
  2107.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  2108.                 }
  2109.             }
  2110.         }catch(Throwable t) {
  2111.             log.error(t.getMessage(),t);
  2112.         }
  2113.         if(mergeList==null) {
  2114.             mergeList = new ArrayList<>();
  2115.             mergeList.add(postOutRequestHandlers);
  2116.             mergeList.add(tipiPostOutRequestHandlers);
  2117.         }
  2118.         return mergeList;
  2119.     }
  2120.     private static void _postOutRequestHandler(PostOutRequestContext context,MsgDiagnostico msgDiag,Logger log, PostOutRequestHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  2121.         if(handlers!=null){
  2122.             for(int i=0; i<handlers.length; i++){
  2123.                 try{
  2124.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  2125.                     handlers[i].invoke(context);
  2126.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  2127.                 }catch(Throwable e){
  2128.                     // Sollevo l'eccezione
  2129.                     HandlerException ex = null;
  2130.                     if(e instanceof HandlerException){
  2131.                         ex = (HandlerException) e;
  2132.                     }else{
  2133.                         ex = new HandlerException(e.getMessage(),e);
  2134.                     }
  2135.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  2136.                     throw ex;
  2137.                 }
  2138.             }
  2139.         }
  2140.     }
  2141.     
  2142.     public static void preInResponse(PreInResponseContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  2143.         
  2144.         if(!GestoreHandlers.initialize){
  2145.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  2146.         }
  2147.     
  2148.         if(context.getDataElaborazioneMessaggio()==null){
  2149.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  2150.         }
  2151.         
  2152.         // genero date casuali 
  2153.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2154.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2155.         }
  2156.         
  2157.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  2158.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.preInResponseHandlers, GestoreHandlers.tipiPreInResponseHandlers, log);
  2159.         PreInResponseHandler [] preInResponseHandlersUsers = (PreInResponseHandler []) mergeWithImplementation.get(0);
  2160.         String [] tipiPreInResponseHandlersUsers = (String []) mergeWithImplementation.get(1);
  2161.         
  2162.         // gestisco handler built-in e user
  2163.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  2164.             List<Object[]> list =  merge(GestoreHandlers.preInResponseHandlersBuiltIn, GestoreHandlers.tipiPreInResponseHandlersBuiltIn,
  2165.                     preInResponseHandlersUsers, tipiPreInResponseHandlersUsers, new PreInResponseHandler [1]);
  2166.             PreInResponseHandler [] handlers = (PreInResponseHandler []) list.get(0);
  2167.             String [] tipiHandlers = toStringArray(list.get(1));
  2168.             _preInResponseHandler(context, msgDiag, log, handlers, tipiHandlers, "PreInResponseHandler");
  2169.         }
  2170.         else {
  2171.             _preInResponseHandler(context, msgDiag, log, GestoreHandlers.preInResponseHandlersBuiltIn, GestoreHandlers.tipiPreInResponseHandlersBuiltIn, "PreInResponseHandler");
  2172.             _preInResponseHandler(context, msgDiag, log, preInResponseHandlersUsers, tipiPreInResponseHandlersUsers, "PreInResponseHandler");
  2173.         }
  2174.         
  2175.     }
  2176.     private static List<Object[]> mergeWithImplementationEngine(PreInResponseContext context,PreInResponseHandler [] preInResponseHandlers,String [] tipiPreInResponseHandlers,
  2177.             Logger log) {
  2178.         List<Object[]> mergeList = null;
  2179.         try{
  2180.             List<String> tipiPorta=null;
  2181.             if(context!=null) {
  2182.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  2183.                 
  2184.                 RequestInfo requestInfo = null;
  2185.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  2186.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  2187.                 }
  2188.                 
  2189.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  2190.                     IDPortaDelegata idPD = null;
  2191.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null) {
  2192.                         idPD = context.getIntegrazione().getIdPD();
  2193.                     }
  2194.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2195.                         idPD = new IDPortaDelegata();
  2196.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2197.                     }
  2198.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  2199.                     tipiPorta=configurazionePdDManager.getPreInResponseHandlers(pd);
  2200.                     /**System.out.println("PreInResponseContext find PD '"+pd.getNome()+"'");*/
  2201.                 }
  2202.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  2203.                     IDPortaApplicativa idPA = null;
  2204.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null) {
  2205.                         idPA = context.getIntegrazione().getIdPA();
  2206.                     }
  2207.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2208.                         idPA = new IDPortaApplicativa();
  2209.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2210.                     }
  2211.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  2212.                     tipiPorta=configurazionePdDManager.getPreInResponseHandlers(pa);
  2213.                     /**System.out.println("PreInResponseContext find PA '"+pa.getNome()+"'");*/
  2214.                 }
  2215.             }
  2216.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  2217.                 List<PreInResponseHandler> listHandler = new ArrayList<>();
  2218.                 List<String> listTipi = new ArrayList<>();
  2219.                 if(preInResponseHandlers!=null && preInResponseHandlers.length>0) {
  2220.                     for (int i = 0; i < preInResponseHandlers.length; i++) {
  2221.                         listHandler.add(preInResponseHandlers[i]);
  2222.                         listTipi.add(tipiPreInResponseHandlers[i]);
  2223.                     }
  2224.                 }
  2225.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  2226.                 for (String tipoPorta : tipiPorta) {
  2227.                     if(!listTipi.contains(tipoPorta)) {
  2228.                         try {
  2229.                             PreInResponseHandler handler = pluginLoader.newPreInResponseHandler(tipoPorta);
  2230.                             listHandler.add(handler);
  2231.                             listTipi.add(tipoPorta);
  2232.                         }catch(Throwable t) {
  2233.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  2234.                             // Sollevo l'eccezione
  2235.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  2236.                             ex.setIdentitaHandler("PreInResponseHandler"+" ["+tipoPorta+"]");
  2237.                             throw ex;
  2238.                         }
  2239.                     }
  2240.                 }
  2241.                 if(!listHandler.isEmpty()) {
  2242.                     mergeList = new ArrayList<>();
  2243.                     mergeList.add(listHandler.toArray(new PreInResponseHandler[listHandler.size()]));
  2244.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  2245.                 }
  2246.             }
  2247.         }catch(Throwable t) {
  2248.             log.error(t.getMessage(),t);
  2249.         }
  2250.         if(mergeList==null) {
  2251.             mergeList = new ArrayList<>();
  2252.             mergeList.add(preInResponseHandlers);
  2253.             mergeList.add(tipiPreInResponseHandlers);
  2254.         }
  2255.         return mergeList;
  2256.     }
  2257.     private static void _preInResponseHandler(PreInResponseContext context,MsgDiagnostico msgDiag,Logger log, PreInResponseHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  2258.         if(handlers!=null){
  2259.             for(int i=0; i<handlers.length; i++){
  2260.                 try{
  2261.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  2262.                     handlers[i].invoke(context);
  2263.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  2264.                 }catch(Throwable e){
  2265.                     // Sollevo l'eccezione
  2266.                     HandlerException ex = null;
  2267.                     if(e instanceof HandlerException){
  2268.                         ex = (HandlerException) e;
  2269.                     }else{
  2270.                         ex = new HandlerException(e.getMessage(),e);
  2271.                     }
  2272.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  2273.                     throw ex;
  2274.                 }
  2275.             }
  2276.         }
  2277.     }
  2278.     
  2279.     public static void inResponse(InResponseContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  2280.         
  2281.         if(!GestoreHandlers.initialize){
  2282.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  2283.         }
  2284.     
  2285.         if(context.getDataElaborazioneMessaggio()==null){
  2286.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  2287.         }
  2288.         
  2289.         // genero date casuali 
  2290.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2291.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2292.         }
  2293.         
  2294.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  2295.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.inResponseHandlers, GestoreHandlers.tipiInResponseHandlers, log);
  2296.         InResponseHandler [] inResponseHandlersUsers = (InResponseHandler []) mergeWithImplementation.get(0);
  2297.         String [] tipiInResponseHandlersUsers = (String []) mergeWithImplementation.get(1);
  2298.         
  2299.         // gestisco handler built-in e user
  2300.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  2301.             List<Object[]> list =  merge(GestoreHandlers.inResponseHandlersBuiltIn, GestoreHandlers.tipiInResponseHandlersBuiltIn,
  2302.                     inResponseHandlersUsers, tipiInResponseHandlersUsers, new InResponseHandler [1]);
  2303.             InResponseHandler [] handlers = (InResponseHandler []) list.get(0);
  2304.             String [] tipiHandlers = toStringArray(list.get(1));
  2305.             _inResponseHandler(context, msgDiag, log, handlers, tipiHandlers, "InResponseHandler");
  2306.         }
  2307.         else {
  2308.             _inResponseHandler(context, msgDiag, log, GestoreHandlers.inResponseHandlersBuiltIn, GestoreHandlers.tipiInResponseHandlersBuiltIn, "InResponseHandler");
  2309.             _inResponseHandler(context, msgDiag, log, inResponseHandlersUsers, tipiInResponseHandlersUsers, "InResponseHandler");
  2310.         }
  2311.         
  2312.     }
  2313.     private static List<Object[]> mergeWithImplementationEngine(InResponseContext context,InResponseHandler [] inResponseHandlers,String [] tipiInResponseHandlers,
  2314.             Logger log) {
  2315.         List<Object[]> mergeList = null;
  2316.         try{
  2317.             List<String> tipiPorta=null;
  2318.             if(context!=null) {
  2319.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  2320.                 
  2321.                 RequestInfo requestInfo = null;
  2322.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  2323.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  2324.                 }
  2325.                 
  2326.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  2327.                     IDPortaDelegata idPD = null;
  2328.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null) {
  2329.                         idPD = context.getIntegrazione().getIdPD();
  2330.                     }
  2331.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2332.                         idPD = new IDPortaDelegata();
  2333.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2334.                     }
  2335.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  2336.                     tipiPorta=configurazionePdDManager.getInResponseHandlers(pd);
  2337.                     /**System.out.println("InResponseContext find PD '"+pd.getNome()+"'");*/
  2338.                 }
  2339.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  2340.                     IDPortaApplicativa idPA = null;
  2341.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null) {
  2342.                         idPA = context.getIntegrazione().getIdPA();
  2343.                     }
  2344.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2345.                         idPA = new IDPortaApplicativa();
  2346.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2347.                     }
  2348.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  2349.                     tipiPorta=configurazionePdDManager.getInResponseHandlers(pa);
  2350.                     /**System.out.println("InResponseContext find PA '"+pa.getNome()+"'");*/
  2351.                 }
  2352.             }
  2353.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  2354.                 List<InResponseHandler> listHandler = new ArrayList<>();
  2355.                 List<String> listTipi = new ArrayList<>();
  2356.                 if(inResponseHandlers!=null && inResponseHandlers.length>0) {
  2357.                     for (int i = 0; i < inResponseHandlers.length; i++) {
  2358.                         listHandler.add(inResponseHandlers[i]);
  2359.                         listTipi.add(tipiInResponseHandlers[i]);
  2360.                     }
  2361.                 }
  2362.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  2363.                 for (String tipoPorta : tipiPorta) {
  2364.                     if(!listTipi.contains(tipoPorta)) {
  2365.                         try {
  2366.                             InResponseHandler handler = pluginLoader.newInResponseHandler(tipoPorta);
  2367.                             listHandler.add(handler);
  2368.                             listTipi.add(tipoPorta);
  2369.                         }catch(Throwable t) {
  2370.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  2371.                             // Sollevo l'eccezione
  2372.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  2373.                             ex.setIdentitaHandler("InResponseHandler"+" ["+tipoPorta+"]");
  2374.                             throw ex;
  2375.                         }
  2376.                     }
  2377.                 }
  2378.                 if(!listHandler.isEmpty()) {
  2379.                     mergeList = new ArrayList<>();
  2380.                     mergeList.add(listHandler.toArray(new InResponseHandler[listHandler.size()]));
  2381.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  2382.                 }
  2383.             }
  2384.         }catch(Throwable t) {
  2385.             log.error(t.getMessage(),t);
  2386.         }
  2387.         if(mergeList==null) {
  2388.             mergeList = new ArrayList<>();
  2389.             mergeList.add(inResponseHandlers);
  2390.             mergeList.add(tipiInResponseHandlers);
  2391.         }
  2392.         return mergeList;
  2393.     }
  2394.     private static void _inResponseHandler(InResponseContext context,MsgDiagnostico msgDiag,Logger log, InResponseHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  2395.         if(handlers!=null){
  2396.             for(int i=0; i<handlers.length; i++){
  2397.                 try{
  2398.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  2399.                     handlers[i].invoke(context);
  2400.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  2401.                 }catch(Throwable e){
  2402.                     // Sollevo l'eccezione
  2403.                     HandlerException ex = null;
  2404.                     if(e instanceof HandlerException){
  2405.                         ex = (HandlerException) e;
  2406.                     }else{
  2407.                         ex = new HandlerException(e.getMessage(),e);
  2408.                     }
  2409.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  2410.                     throw ex;
  2411.                 }
  2412.             }
  2413.         }
  2414.     }
  2415.     
  2416.     public static void outResponse(OutResponseContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  2417.         
  2418.         if(!GestoreHandlers.initialize){
  2419.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  2420.         }
  2421.     
  2422.         if(context.getDataElaborazioneMessaggio()==null){
  2423.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  2424.         }
  2425.         
  2426.         // genero date casuali 
  2427.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2428.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2429.         }
  2430.         
  2431.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  2432.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.outResponseHandlers, GestoreHandlers.tipiOutResponseHandlers, log);
  2433.         OutResponseHandler [] outResponseHandlersUsers = (OutResponseHandler []) mergeWithImplementation.get(0);
  2434.         String [] tipiOutResponseHandlersUsers = (String []) mergeWithImplementation.get(1);
  2435.         
  2436.         // gestisco handler built-in e user
  2437.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  2438.             List<Object[]> list =  merge(GestoreHandlers.outResponseHandlersBuiltIn, GestoreHandlers.tipiOutResponseHandlersBuiltIn,
  2439.                     outResponseHandlersUsers, tipiOutResponseHandlersUsers, new OutResponseHandler [1]);
  2440.             OutResponseHandler [] handlers = (OutResponseHandler []) list.get(0);
  2441.             String [] tipiHandlers = toStringArray(list.get(1));
  2442.             _outResponseHandler(context, msgDiag, log, handlers, tipiHandlers, "OutResponseHandler");
  2443.         }
  2444.         else {
  2445.             _outResponseHandler(context, msgDiag, log, GestoreHandlers.outResponseHandlersBuiltIn, GestoreHandlers.tipiOutResponseHandlersBuiltIn, "OutResponseHandler");
  2446.             _outResponseHandler(context, msgDiag, log, outResponseHandlersUsers, tipiOutResponseHandlersUsers, "OutResponseHandler");
  2447.         }
  2448.         
  2449.     }
  2450.     private static List<Object[]> mergeWithImplementationEngine(OutResponseContext context,OutResponseHandler [] outResponseHandlers,String [] tipiOutResponseHandlers,
  2451.             Logger log) {
  2452.         List<Object[]> mergeList = null;
  2453.         try{
  2454.             List<String> tipiPorta=null;
  2455.             if(context!=null) {
  2456.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  2457.                 
  2458.                 RequestInfo requestInfo = null;
  2459.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  2460.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  2461.                 }
  2462.                 
  2463.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  2464.                     IDPortaDelegata idPD = null;
  2465.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null) {
  2466.                         idPD = context.getIntegrazione().getIdPD();
  2467.                     }
  2468.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2469.                         idPD = new IDPortaDelegata();
  2470.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2471.                     }
  2472.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  2473.                     tipiPorta=configurazionePdDManager.getOutResponseHandlers(pd);
  2474.                     /**System.out.println("OutResponseContext find PD '"+pd.getNome()+"'");*/
  2475.                 }
  2476.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  2477.                     IDPortaApplicativa idPA = null;
  2478.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null) {
  2479.                         idPA = context.getIntegrazione().getIdPA();
  2480.                     }
  2481.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2482.                         idPA = new IDPortaApplicativa();
  2483.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2484.                     }
  2485.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  2486.                     tipiPorta=configurazionePdDManager.getOutResponseHandlers(pa);
  2487.                     /**System.out.println("OutResponseContext find PA '"+pa.getNome()+"'");*/
  2488.                 }
  2489.             }
  2490.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  2491.                 List<OutResponseHandler> listHandler = new ArrayList<>();
  2492.                 List<String> listTipi = new ArrayList<>();
  2493.                 if(outResponseHandlers!=null && outResponseHandlers.length>0) {
  2494.                     for (int i = 0; i < outResponseHandlers.length; i++) {
  2495.                         listHandler.add(outResponseHandlers[i]);
  2496.                         listTipi.add(tipiOutResponseHandlers[i]);
  2497.                     }
  2498.                 }
  2499.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  2500.                 for (String tipoPorta : tipiPorta) {
  2501.                     if(!listTipi.contains(tipoPorta)) {
  2502.                         try {
  2503.                             OutResponseHandler handler = pluginLoader.newOutResponseHandler(tipoPorta);
  2504.                             listHandler.add(handler);
  2505.                             listTipi.add(tipoPorta);
  2506.                         }catch(Throwable t) {
  2507.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  2508.                             // Sollevo l'eccezione
  2509.                             HandlerException ex = new HandlerException(t.getMessage(),t);
  2510.                             ex.setIdentitaHandler("OutResponseHandler"+" ["+tipoPorta+"]");
  2511.                             throw ex;
  2512.                         }
  2513.                     }
  2514.                 }
  2515.                 if(!listHandler.isEmpty()) {
  2516.                     mergeList = new ArrayList<>();
  2517.                     mergeList.add(listHandler.toArray(new OutResponseHandler[listHandler.size()]));
  2518.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  2519.                 }
  2520.             }
  2521.         }catch(Throwable t) {
  2522.             log.error(t.getMessage(),t);
  2523.         }
  2524.         if(mergeList==null) {
  2525.             mergeList = new ArrayList<>();
  2526.             mergeList.add(outResponseHandlers);
  2527.             mergeList.add(tipiOutResponseHandlers);
  2528.         }
  2529.         return mergeList;
  2530.     }
  2531.     private static void _outResponseHandler(OutResponseContext context,MsgDiagnostico msgDiag,Logger log, OutResponseHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  2532.         if(handlers!=null){
  2533.             for(int i=0; i<handlers.length; i++){
  2534.                 try{
  2535.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  2536.                     handlers[i].invoke(context);
  2537.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  2538.                 }catch(Throwable e){
  2539.                     // Sollevo l'eccezione
  2540.                     HandlerException ex = null;
  2541.                     if(e instanceof HandlerException){
  2542.                         ex = (HandlerException) e;
  2543.                     }else{
  2544.                         ex = new HandlerException(e.getMessage(),e);
  2545.                     }
  2546.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  2547.                     throw ex;
  2548.                 }
  2549.             }
  2550.         }
  2551.     }
  2552.     
  2553.     public static void postOutResponse(PostOutResponseContext context,MsgDiagnostico msgDiag,Logger log) {
  2554.         
  2555.         if(!GestoreHandlers.initialize){
  2556.             GestoreHandlers.initialize(msgDiag,log,context.getStato());
  2557.         }
  2558.     
  2559.         if(context.getDataElaborazioneMessaggio()==null){
  2560.             context.setDataElaborazioneMessaggio(DateManager.getDate());
  2561.         }
  2562.         
  2563.         // genero date casuali 
  2564.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2565.             context.setDataElaborazioneMessaggio(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2566.         }
  2567.         
  2568.         // unisco handler generali (props+config) con eventuali handler definiti sulla porta
  2569.         List<Object[]> mergeWithImplementation = mergeWithImplementationEngine(context,GestoreHandlers.postOutResponseHandlers, GestoreHandlers.tipiPostOutResponseHandlers, log);
  2570.         PostOutResponseHandler [] postOutResponseHandlersUsers = (PostOutResponseHandler []) mergeWithImplementation.get(0);
  2571.         String [] tipiPostOutResponseHandlersUsers = (String []) mergeWithImplementation.get(1);
  2572.         
  2573.         // gestisco handler built-in e user
  2574.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  2575.             List<Object[]> list =  merge(GestoreHandlers.postOutResponseHandlersBuiltIn, GestoreHandlers.tipiPostOutResponseHandlersBuiltIn,
  2576.                     postOutResponseHandlersUsers, tipiPostOutResponseHandlersUsers, new PostOutResponseHandler [1]);
  2577.             PostOutResponseHandler [] handlers = (PostOutResponseHandler []) list.get(0);
  2578.             String [] tipiHandlers = toStringArray(list.get(1));
  2579.             _postOutResponseHandler(context, msgDiag, log, handlers, tipiHandlers, "PostOutResponseHandler");
  2580.         }
  2581.         else {
  2582.             _postOutResponseHandler(context, msgDiag, log, GestoreHandlers.postOutResponseHandlersBuiltIn, GestoreHandlers.tipiPostOutResponseHandlersBuiltIn, "PostOutResponseHandler");
  2583.             _postOutResponseHandler(context, msgDiag, log, postOutResponseHandlersUsers, tipiPostOutResponseHandlersUsers, "PostOutResponseHandler");
  2584.         }

  2586.         // Rilascio risorse per la generazione di date casuali
  2587.         GestoreHandlers.rilasciaRisorseDemoMode((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  2588.     }
  2589.     private static List<Object[]> mergeWithImplementationEngine(PostOutResponseContext context,PostOutResponseHandler [] postOutResponseHandlers,String [] tipiPostOutResponseHandlers,
  2590.             Logger log) {
  2591.         List<Object[]> mergeList = null;
  2592.         try{
  2593.             List<String> tipiPorta=null;
  2594.             if(context!=null) {
  2595.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  2596.                 
  2597.                 RequestInfo requestInfo = null;
  2598.                 if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  2599.                     requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  2600.                 }
  2601.                 
  2602.                 if(TipoPdD.DELEGATA.equals(context.getTipoPorta())) {
  2603.                     IDPortaDelegata idPD = null;
  2604.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null) {
  2605.                         idPD = context.getIntegrazione().getIdPD();
  2606.                     }
  2607.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2608.                         idPD = new IDPortaDelegata();
  2609.                         idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2610.                     }
  2611.                     PortaDelegata pd=configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  2612.                     tipiPorta=configurazionePdDManager.getPostOutResponseHandlers(pd);
  2613.                     /**System.out.println("PostOutResponseContext find PD '"+pd.getNome()+"'");*/
  2614.                 }
  2615.                 else if(TipoPdD.APPLICATIVA.equals(context.getTipoPorta())) {
  2616.                     IDPortaApplicativa idPA = null;
  2617.                     if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null) {
  2618.                         idPA = context.getIntegrazione().getIdPA();
  2619.                     }
  2620.                     else if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  2621.                         idPA = new IDPortaApplicativa();
  2622.                         idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  2623.                     }
  2624.                     PortaApplicativa pa=configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  2625.                     tipiPorta=configurazionePdDManager.getPostOutResponseHandlers(pa);
  2626.                     /**System.out.println("PostOutResponseContext find PA '"+pa.getNome()+"'");*/
  2627.                 }
  2628.             }
  2629.             if(tipiPorta!=null && !tipiPorta.isEmpty()) {
  2630.                 List<PostOutResponseHandler> listHandler = new ArrayList<>();
  2631.                 List<String> listTipi = new ArrayList<>();
  2632.                 if(postOutResponseHandlers!=null && postOutResponseHandlers.length>0) {
  2633.                     for (int i = 0; i < postOutResponseHandlers.length; i++) {
  2634.                         listHandler.add(postOutResponseHandlers[i]);
  2635.                         listTipi.add(tipiPostOutResponseHandlers[i]);
  2636.                     }
  2637.                 }
  2638.                 PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  2639.                 for (String tipoPorta : tipiPorta) {
  2640.                     if(!listTipi.contains(tipoPorta)) {
  2641.                         try {
  2642.                             PostOutResponseHandler handler = pluginLoader.newPostOutResponseHandler(tipoPorta);
  2643.                             listHandler.add(handler);
  2644.                             listTipi.add(tipoPorta);
  2645.                         }catch(Throwable t) {
  2646.                             // Non sollevo l'eccezione poiche' dove viene chiamato questo handler e' finita la gestione, quindi l'eccezione non causa altri avvenimenti
  2647.                             log.error("NewInstance '"+tipoPorta+"' failed: "+t.getMessage(),t);
  2648.                         }
  2649.                     }
  2650.                 }
  2651.                 if(!listHandler.isEmpty()) {
  2652.                     mergeList = new ArrayList<>();
  2653.                     mergeList.add(listHandler.toArray(new PostOutResponseHandler[listHandler.size()]));
  2654.                     mergeList.add(listTipi.toArray(new String[listTipi.size()]));
  2655.                 }
  2656.             }
  2657.         }catch(Throwable t) {
  2658.             log.error(t.getMessage(),t);
  2659.         }
  2660.         if(mergeList==null) {
  2661.             mergeList = new ArrayList<>();
  2662.             mergeList.add(postOutResponseHandlers);
  2663.             mergeList.add(tipiPostOutResponseHandlers);
  2664.         }
  2665.         return mergeList;
  2666.     }
  2667.     private static void _postOutResponseHandler(PostOutResponseContext context,MsgDiagnostico msgDiag,Logger log, PostOutResponseHandler [] handlers, String [] tipiHandlers, String name) {
  2668.         if(handlers!=null){
  2669.             for(int i=0; i<handlers.length; i++){
  2670.                 try{
  2671.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  2672.                     handlers[i].invoke(context);
  2673.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  2674.                 }catch(Throwable e){
  2675.                     // Non sollevo l'eccezione poiche' dove viene chiamato questo handler e' finita la gestione, quindi l'eccezione non causa altri avvenimenti
  2676.                     // Registro solamento l'evento
  2677.                     if(handlers[i] instanceof org.openspcoop2.pdd.core.handlers.transazioni.PostOutResponseHandler) {
  2678.                         // altrimenti succede questo errore, non esistendo più la transazione:
  2679.                         // Errore durante l'emissione del msg diagnostico nel contesto della transazione: Non abilitata la gestione delle transazioni stateful 
  2680.                         // org.openspcoop2.pdd.core.transazioni.TransactionStatefulNotSupportedException: Non abilitata la gestione delle transazioni stateful
  2681.                         if(log!=null) {
  2682.                             log.error(name+" ["+tipiHandlers[i]+"]"+e.getMessage(),e);
  2683.                         }
  2684.                     }
  2685.                     else {
  2686.                         msgDiag.logErroreGenerico(e,name+" ["+tipiHandlers[i]+"]");
  2687.                     }
  2688.                 }
  2689.             }
  2690.         }
  2691.     }
  2692.     
  2693.     
  2694.     
  2695.     public static void integrationManagerRequest(IntegrationManagerRequestContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  2696.         
  2697.         if(GestoreHandlers.initialize==false){
  2698.             GestoreHandlers.initialize(msgDiag,log,null);
  2699.         }
  2700.         
  2701.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2702.             // genero date casuali
  2703.             if(context.getDataRichiestaOperazione()!=null){
  2704.                 context.setDataRichiestaOperazione(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2705.             }
  2706.         }
  2707.         
  2708.         // gestisco handler built-in e user
  2709.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  2710.             List<Object[]> list =  merge(GestoreHandlers.integrationManagerRequestHandlersBuiltIn, GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn,
  2711.                     GestoreHandlers.integrationManagerRequestHandlers, GestoreHandlers.tipiIntegrationManagerRequestHandlers, new IntegrationManagerRequestHandler [1]);
  2712.             IntegrationManagerRequestHandler [] handlers = (IntegrationManagerRequestHandler []) list.get(0);
  2713.             String [] tipiHandlers = toStringArray(list.get(1));
  2714.             _integrationManagerRequestHandler(context, msgDiag, log, handlers, tipiHandlers, "IntegrationManagerRequestHandler");
  2715.         }
  2716.         else {
  2717.             _integrationManagerRequestHandler(context, msgDiag, log, GestoreHandlers.integrationManagerRequestHandlersBuiltIn, GestoreHandlers.tipiIntegrationManagerRequestHandlersBuiltIn, "IntegrationManagerRequestHandler");
  2718.             _integrationManagerRequestHandler(context, msgDiag, log, GestoreHandlers.integrationManagerRequestHandlers, GestoreHandlers.tipiIntegrationManagerRequestHandlers, "IntegrationManagerRequestHandler");
  2719.         }
  2720.     }
  2721.     private static void _integrationManagerRequestHandler(IntegrationManagerRequestContext context,MsgDiagnostico msgDiag,Logger log, IntegrationManagerRequestHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  2722.         if(handlers!=null){
  2723.             for(int i=0; i<handlers.length; i++){
  2724.                 try{
  2725.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  2726.                     handlers[i].invoke(context);
  2727.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  2728.                 }catch(Throwable e){
  2729.                     // Sollevo l'eccezione
  2730.                     HandlerException ex = null;
  2731.                     if(e instanceof HandlerException){
  2732.                         ex = (HandlerException) e;
  2733.                     }else{
  2734.                         ex = new HandlerException(e.getMessage(),e);
  2735.                     }
  2736.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  2737.                     throw ex;
  2738.                 }
  2739.             }
  2740.         }
  2741.     }
  2742.     
  2743.     
  2744.     public static void integrationManagerResponse(IntegrationManagerResponseContext context,MsgDiagnostico msgDiag,Logger log) throws HandlerException{
  2745.         
  2746.         if(GestoreHandlers.initialize==false){
  2747.             GestoreHandlers.initialize(msgDiag,log,null);
  2748.         }
  2749.         
  2750.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)!=null){
  2751.             // genero date casuali
  2752.             if(context.getDataRichiestaOperazione()!=null){
  2753.                 context.setDataRichiestaOperazione(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2754.             }
  2755.             if(context.getDataCompletamentoOperazione()!=null){
  2756.                 context.setDataCompletamentoOperazione(GestoreHandlers.generatoreCasualeDati.getProssimaData((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)));
  2757.             }
  2758.         }
  2759.         
  2760.         // gestisco handler built-in e user
  2761.         if(properties.isMergeHandlerBuiltInAndHandlerUser()) {
  2762.             List<Object[]> list =  merge(GestoreHandlers.integrationManagerResponseHandlersBuiltIn, GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn,
  2763.                     GestoreHandlers.integrationManagerResponseHandlers, GestoreHandlers.tipiIntegrationManagerResponseHandlers, new IntegrationManagerResponseHandler [1]);
  2764.             IntegrationManagerResponseHandler [] handlers = (IntegrationManagerResponseHandler []) list.get(0);
  2765.             String [] tipiHandlers = toStringArray(list.get(1));
  2766.             _integrationManagerResponseHandler(context, msgDiag, log, handlers, tipiHandlers, "IntegrationManagerResponseHandler");
  2767.         }
  2768.         else {
  2769.             _integrationManagerResponseHandler(context, msgDiag, log, GestoreHandlers.integrationManagerResponseHandlersBuiltIn, GestoreHandlers.tipiIntegrationManagerResponseHandlersBuiltIn, "IntegrationManagerResponseHandler");
  2770.             _integrationManagerResponseHandler(context, msgDiag, log, GestoreHandlers.integrationManagerResponseHandlers, GestoreHandlers.tipiIntegrationManagerResponseHandlers, "IntegrationManagerResponseHandler");
  2771.         }
  2772.         
  2773.         // Rilascio risorse per la generazione di date casuali
  2774.         GestoreHandlers.rilasciaRisorseDemoMode((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  2775.     }
  2776.     private static void _integrationManagerResponseHandler(IntegrationManagerResponseContext context,MsgDiagnostico msgDiag,Logger log, IntegrationManagerResponseHandler [] handlers, String [] tipiHandlers, String name) throws HandlerException{
  2777.         if(handlers!=null){
  2778.             for(int i=0; i<handlers.length; i++){
  2779.                 try{
  2780.                     emitDiagnosticInvokeHandlerStart(handlers[i], msgDiag, log);
  2781.                     handlers[i].invoke(context);
  2782.                     emitDiagnosticInvokeHandlerEnd(handlers[i], msgDiag, log);
  2783.                 }catch(Throwable e){
  2784.                     // Sollevo l'eccezione
  2785.                     HandlerException ex = null;
  2786.                     if(e instanceof HandlerException){
  2787.                         ex = (HandlerException) e;
  2788.                     }else{
  2789.                         ex = new HandlerException(e.getMessage(),e);
  2790.                     }
  2791.                     ex.setIdentitaHandler(name+" ["+tipiHandlers[i]+"]");
  2792.                     throw ex;
  2793.                 }
  2794.             }
  2795.         }
  2796.     }

  2798.     
  2799.     private static void rilasciaRisorseDemoMode(String idCluster){
  2800.         if(GestoreHandlers.properties.generazioneDateCasualiLogAbilitato() && idCluster!=null){
  2801.             GeneratoreCasualeDate.getGeneratoreCasualeDate().releaseResource(idCluster);
  2802.         }
  2803.     }
  2804. }
Created with JaCoCo 0.8.8.202204050719