AllarmiUtils.java

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

  21. package org.openspcoop2.monitor.engine.alarm.utils;

  23. import java.util.ArrayList;
  24. import java.util.HashMap;
  25. import java.util.List;
  26. import java.util.Map;

  28. import org.apache.commons.lang.StringUtils;
  29. import org.openspcoop2.core.allarmi.Allarme;
  30. import org.openspcoop2.core.allarmi.AllarmeFiltro;
  31. import org.openspcoop2.core.allarmi.constants.StatoAllarme;
  32. import org.openspcoop2.core.allarmi.constants.TipoAllarme;
  33. import org.openspcoop2.core.allarmi.utils.AllarmiConverterUtils;
  34. import org.openspcoop2.core.id.IDServizio;
  35. import org.openspcoop2.core.id.IDSoggetto;
  36. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  37. import org.openspcoop2.monitor.engine.alarm.AlarmEngineConfig;
  38. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeBean;
  39. import org.openspcoop2.monitor.engine.dynamic.DynamicFactory;
  40. import org.openspcoop2.monitor.engine.dynamic.IDynamicLoader;
  41. import org.openspcoop2.monitor.sdk.condition.Context;
  42. import org.openspcoop2.monitor.sdk.plugins.IAlarmProcessing;
  43. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  44. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  45. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  46. import org.openspcoop2.utils.beans.BeanUtils;
  47. import org.openspcoop2.utils.transport.http.HttpConstants;
  48. import org.openspcoop2.utils.transport.http.HttpRequest;
  49. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  50. import org.openspcoop2.utils.transport.http.HttpResponse;
  51. import org.openspcoop2.utils.transport.http.HttpUtilities;
  52. import org.slf4j.Logger;

  54. /**     
  55.  * AllarmiUtils
  56.  *
  57.  * @author Poli Andrea (poli@link.it)
  58.  * @author $Author$
  59.  * @version $Rev$, $Date$
  60.  */
  61. public class AllarmiUtils {

  63.     
  64.     /***
  65.      * 
  66.      * Restituisce true se i tipi indicati sono compatibili, false altrimenti.
  67.      * 
  68.      * @param filtro
  69.      * @return
  70.      */
  71.     public static boolean controllaTipiIndicatiNelFiltro(AllarmeFiltro filtro, String valoreQualsiasi) throws Exception{

  73.         String tipoMittente = filtro.getTipoFruitore();
  74.         String tipoDestinatario = filtro.getTipoErogatore();
  75.         String tipoServizio = filtro.getTipoServizio();

  77.         List<String> protocolloMittente = new ArrayList<>();
  78.         List<String> protocolloDestinatario = new ArrayList<>();
  79.         List<String> protocolloServizio = new ArrayList<>();


  82.         try{

  84.             // 1. Carico i tipi disponibili per mittente, destinatario e servizio, se uno dei tre non e' stato scelto ('*') la lista risultera' vuota
  85.             if(!tipoDestinatario.equals(valoreQualsiasi) ){
  86.                 IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByOrganizationType(tipoDestinatario);
  87.                 protocolloDestinatario.add(protocolFactory.getProtocol());
  88.                 //              tipiDisponibiliDestinatario = protocolFactory.createProtocolConfiguration().getTipiSoggetti();
  89.             }

  91.             if(!tipoMittente.equals(valoreQualsiasi)){
  92.                 IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByOrganizationType(tipoMittente);
  93.                 protocolloMittente.add(protocolFactory.getProtocol());
  94.                 //              tipiDisponibiliMittente = protocolFactory.createProtocolConfiguration().getTipiSoggetti();
  95.             }

  97.             if(!tipoServizio.equals(valoreQualsiasi)){
  98.                 IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByServiceType(tipoServizio);
  99.                 protocolloServizio.add(protocolFactory.getProtocol());
  100.                 //              tipiDisponibiliServizio = protocolFactory.createProtocolConfiguration().getTipiServizi();
  101.             }

  103.             // Inserisco tutti i tipi trovati in una mappa, se i tre tipi sono compatibili, l'elenco delle chiavi coincide con la dimensione delle liste di quelli settati.
  104.             Map<String, String> mappaProtocolli = new HashMap<>();
  105.             if(protocolloServizio != null && protocolloServizio.size() > 0)
  106.                 for (String tipo : protocolloServizio) {
  107.                     if(!mappaProtocolli.containsKey(tipo))
  108.                         mappaProtocolli.put(tipo, tipo);
  109.                 }

  111.             if(protocolloMittente != null && protocolloMittente.size() > 0)
  112.                 for (String tipo : protocolloMittente) {
  113.                     if(!mappaProtocolli.containsKey(tipo))
  114.                         mappaProtocolli.put(tipo, tipo);
  115.                 }

  117.             if(protocolloDestinatario != null && protocolloDestinatario.size() > 0)
  118.                 for (String tipo : protocolloDestinatario) {
  119.                     if(!mappaProtocolli.containsKey(tipo))
  120.                         mappaProtocolli.put(tipo, tipo);
  121.                 }   

  123.             // controllo di validita  
  124.             if(protocolloDestinatario.size() > 0 && protocolloDestinatario.size() != mappaProtocolli.keySet().size())
  125.                 return false;

  127.             if(protocolloMittente.size() > 0 && protocolloMittente.size() != mappaProtocolli.keySet().size())
  128.                 return false;

  130.             if(protocolloServizio.size() > 0 && protocolloServizio.size() != mappaProtocolli.keySet().size())
  131.                 return false;

  133.             return true;
  134.         }catch(Exception e){
  135.             throw e;
  136.         }
  137.     }
  138.     
  139.     private static HttpRequest buildHttpRequest(AlarmEngineConfig allarmiConfig, String url, HttpRequestMethod method, byte [] content, String contentType) {
  140.         HttpRequest request = new HttpRequest();
  141.         request.setUrl(url);
  142.         request.setContent(content);
  143.         request.setMethod(method);
  144.         request.setContentType(contentType);
  145.         request.setUsername(allarmiConfig.getActiveAlarm_serviceUrl_manager_username());
  146.         request.setPassword(allarmiConfig.getActiveAlarm_serviceUrl_manager_password());
  147.         
  148.         request.setConnectTimeout(allarmiConfig.getActiveAlarm_serviceUrl_connectionTimeout());
  149.         request.setReadTimeout(allarmiConfig.getActiveAlarm_serviceUrl_readConnectionTimeout());
  150.         
  151.         if(allarmiConfig.isActiveAlarm_serviceUrl_https()) {
  152.             request.setHostnameVerifier(allarmiConfig.isActiveAlarm_serviceUrl_https_verificaHostName());
  153.             if(allarmiConfig.isActiveAlarm_serviceUrl_https_autenticazioneServer()) {
  154.                 request.setTrustStorePath(allarmiConfig.getActiveAlarm_serviceUrl_https_truststorePath());
  155.                 request.setTrustStoreType(allarmiConfig.getActiveAlarm_serviceUrl_https_truststoreType());
  156.                 request.setTrustStorePassword(allarmiConfig.getActiveAlarm_serviceUrl_https_truststorePassword());
  157.             }
  158.             else {
  159.                 request.setTrustAllCerts(true);
  160.             }
  161.         }
  162.         return request;
  163.     }
  164.     
  165.     public static void sendToAllarmi(AlarmEngineConfig allarmiConfig, List<String> post_urls, List<String> post_contents, Logger log) throws Exception{
  166.         if(post_urls!=null && post_urls.size()>0){
  167.             for (int i = 0; i < post_urls.size(); i++) {
  168.                 String url = post_urls.get(i);
  169.                 String content = post_contents.get(i);

  171.                 log.debug("Invoke ["+url+"] ...");
  172.                 HttpRequest request = buildHttpRequest(allarmiConfig, url, HttpRequestMethod.POST, content.getBytes(), HttpConstants.CONTENT_TYPE_JSON);                
  173.                 HttpResponse response = HttpUtilities.httpInvoke(request);
  174.                 if(response.getContent()!=null){
  175.                     log.debug("Invoked ["+url+"] Status["+response.getResultHTTPOperation()+"] Message["+new String(response.getContent())+"]");    
  176.                 }
  177.                 else{
  178.                     log.debug("Invoked ["+url+"] Status["+response.getResultHTTPOperation()+"]");
  179.                 }
  180.                 if(response.getResultHTTPOperation()>202){
  181.                     throw new Exception("Error occurs during invoke url["+url+"] Status["+response.getResultHTTPOperation()+"] Message["+new String(response.getContent())+"]");    
  182.                 }   
  183.             }
  184.         }
  185.     }
  186.     
  187.     public static String sendToAllarme(AlarmEngineConfig allarmiConfig, String get_url, Logger log) throws Exception{

  189.         log.debug("Invoke ["+get_url+"] ...");
  190.         HttpRequest request = buildHttpRequest(allarmiConfig, get_url, HttpRequestMethod.GET, null, null);              
  191.         HttpResponse response = HttpUtilities.httpInvoke(request);
  192.         String responseS = null;
  193.         if(response.getContent()!=null){
  194.             responseS = new String(response.getContent());
  195.             log.debug("Invoked ["+get_url+"] Status["+response.getResultHTTPOperation()+"] Payload["+responseS+"]");    
  196.         }
  197.         else{
  198.             log.debug("Invoked ["+get_url+"] Status["+response.getResultHTTPOperation()+"]");
  199.             responseS = "";
  200.         }
  201.         if(response.getResultHTTPOperation()>202){
  202.             throw new Exception("Error occurs during invoke url["+get_url+"] Status["+response.getResultHTTPOperation()+"] Payload["+responseS+"]");    
  203.         }
  204.         else {
  205.             return responseS;
  206.         }

  208.     }
  209.     
  210.     public static void notifyStateActiveThread(boolean isAdd, boolean modificatoStato, boolean modificatoAckwoldegment,
  211.             ConfigurazioneAllarmeBean oldAllarmePrimaModifica, ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  212.         if(TipoAllarme.PASSIVO.equals(allarme.getTipoAllarme())){
  213.             // NOTA: il tipo di allarme non è modificabile.
  214.             log.debug("Allarme ["+allarme.getNome()+"] è passivo. Non viene attivato alcun thread");
  215.             return;
  216.         }
  217.         
  218.         String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  219.         if(prefixUrl.endsWith("/")==false){
  220.             prefixUrl = prefixUrl + "/";
  221.         }
  222.         prefixUrl = prefixUrl + "gestione/attivi/"+allarme.getNome();
  223.         List<String> post_urls = new ArrayList<>();
  224.         List<String> post_contents = new ArrayList<>();
  225.         if(isAdd){
  226.             if(allarme.getEnabled()==1){
  227.                 // start allarme
  228.                 post_urls.add(prefixUrl);
  229.                 post_contents.add("{\"operazione\": \"start\"}");
  230.             }
  231.         }
  232.         else{
  233.             // Se è stato modificato solo lo stato non richiede un stop/restart 
  234.             boolean equals = false;
  235.             StringBuilder bfDiff = null;
  236.             if(oldAllarmePrimaModifica!=null){
  237.                 
  238.                 List<String> fieldEsclusi = new ArrayList<>();
  239.                 fieldEsclusi.add("id");
  240.                 if(modificatoStato){
  241.                     fieldEsclusi.add("stato");
  242.                     fieldEsclusi.add("_value_stato");
  243.                     fieldEsclusi.add("precedenteStato");
  244.                     fieldEsclusi.add("_value_precedenteStato");
  245.                     fieldEsclusi.add("dettaglioStato");
  246.                 }
  247.                 if(modificatoAckwoldegment){
  248.                     fieldEsclusi.add("acknowledged");
  249.                 }
  250.                 
  251.                 // i metodi equals e diff non funzionano in caso di extends
  252.                 
  253.                 Allarme old = new Allarme();
  254.                 BeanUtils.copy(old, oldAllarmePrimaModifica, null);
  255.                 
  256.                 Allarme attuale = new Allarme();
  257.                 BeanUtils.copy(attuale, allarme, null);
  258.                 
  259.                 equals = attuale.equals(old, fieldEsclusi);
  260.                 if(!equals){
  261.                     bfDiff = new StringBuilder();
  262.                     attuale.diff(old, bfDiff, false, fieldEsclusi);
  263.                 }
  264.             }
  265.             if(equals){         
  266.                 if(modificatoStato){
  267.                     StatoAllarme statoAllarme = AllarmiConverterUtils.toStatoAllarme(allarme.getStato());
  268.                     post_urls.add(prefixUrl+"/stato");
  269.                     switch (statoAllarme) {
  270.                     case OK:
  271.                         post_contents.add("{\"stato\": \"OK\"}");
  272.                         break;
  273.                     case WARNING:
  274.                         post_contents.add("{\"stato\": \"WARNING\"}");
  275.                         break;
  276.                     case ERROR:
  277.                         post_contents.add("{\"stato\": \"ERROR\"}");
  278.                         break;
  279.                     }
  280.                 }
  281.                 if(modificatoAckwoldegment){
  282.                     post_urls.add(prefixUrl+"/acknoledgement");
  283.                     if(allarme.getAcknowledged()==1){
  284.                         post_contents.add("{\"acknoledgement\": true}");
  285.                     }
  286.                     else{
  287.                         post_contents.add("{\"acknoledgement\": false}");
  288.                     }
  289.                 }
  290.                 //else{
  291.                 // non è cambiato nulla
  292.                 //}
  293.             }
  294.             else{
  295.                 if(bfDiff!=null){   
  296.                     log.debug("Rilevata modifica, diff: "+bfDiff.toString());
  297.                 }
  298.                 
  299.                 if(allarme.getEnabled()==0){
  300.                     // stop allarme
  301.                     post_urls.add(prefixUrl);
  302.                     post_contents.add("{\"operazione\": \"stop\"}");
  303.                 }
  304.                 else{
  305.                     // restart allarme
  306.                     post_urls.add(prefixUrl);
  307.                     post_contents.add("{\"operazione\": \"restart\"}");
  308.                 }
  309.             }
  310.         }
  311.         AllarmiUtils.sendToAllarmi(allarmiConfig, post_urls, post_contents, log);
  312.     }
  313.     
  314.     public static void stopActiveThreads(List<String> allarmi, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  315.         
  316.         List<String> post_urls = new ArrayList<>();
  317.         List<String> post_contents = new ArrayList<>();
  318.         if(!allarmi.isEmpty()) {
  319.             for (String nomeAllarme : allarmi) {
  320.                 
  321.                 String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  322.                 if(prefixUrl.endsWith("/")==false){
  323.                     prefixUrl = prefixUrl + "/";
  324.                 }
  325.                 prefixUrl = prefixUrl + "gestione/attivi/"+nomeAllarme;
  326.                 post_urls.add(prefixUrl);
  327.                 post_contents.add("{\"operazione\": \"stop\"}");
  328.                 
  329.             }
  330.         }
  331.         
  332.         if(!post_urls.isEmpty()) {
  333.             AllarmiUtils.sendToAllarmi(allarmiConfig, post_urls, post_contents, log);
  334.         }
  335.         
  336.     }
  337.     
  338.     public static void startActiveThread(ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  339.         _manageActiveThreads(allarme, log, allarmiConfig, "start"); 
  340.     }
  341.     public static void restartActiveThread(ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  342.         _manageActiveThreads(allarme, log, allarmiConfig, "restart");   
  343.     }
  344.     public static void stopActiveThread(ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  345.         _manageActiveThreads(allarme, log, allarmiConfig, "stop");  
  346.     }
  347.     public static void _manageActiveThreads(ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig, String operazione) throws Exception{
  348.         
  349.         List<String> post_urls = new ArrayList<>();
  350.         List<String> post_contents = new ArrayList<>();
  351.                 
  352.         String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  353.         if(prefixUrl.endsWith("/")==false){
  354.             prefixUrl = prefixUrl + "/";
  355.         }
  356.         prefixUrl = prefixUrl + "gestione/attivi/"+allarme.getNome();
  357.         post_urls.add(prefixUrl);
  358.         post_contents.add("{\"operazione\": \""+operazione+"\"}");
  359.                 
  360.         AllarmiUtils.sendToAllarmi(allarmiConfig, post_urls, post_contents, log);
  361.         
  362.     }
  363.     
  364.     public static boolean existsActiveThread(ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  365.         if(TipoAllarme.PASSIVO.equals(allarme.getTipoAllarme())){
  366.             // NOTA: il tipo di allarme non è modificabile.
  367.             log.debug("Allarme ["+allarme.getNome()+"] è passivo. Non contiene una immagine");
  368.             return false;
  369.         }
  370.         
  371.         String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  372.         if(prefixUrl.endsWith("/")==false){
  373.             prefixUrl = prefixUrl + "/";
  374.         }
  375.         prefixUrl = prefixUrl + "gestione/attivi/"+allarme.getNome()+"/image";
  376.         log.debug("Invoke ["+prefixUrl+"] ...");
  377.         HttpRequest request = buildHttpRequest(allarmiConfig, prefixUrl, HttpRequestMethod.GET, null, null);                
  378.         HttpResponse response = HttpUtilities.httpInvoke(request);
  379.         return response.getResultHTTPOperation()==200;
  380.     }
  381.     
  382.     public static String getActiveThreadImage(ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  383.         if(TipoAllarme.PASSIVO.equals(allarme.getTipoAllarme())){
  384.             // NOTA: il tipo di allarme non è modificabile.
  385.             log.debug("Allarme ["+allarme.getNome()+"] è passivo. Non contiene una immagine");
  386.             return "L'allarme è passivo";
  387.         }
  388.         
  389.         String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  390.         if(prefixUrl.endsWith("/")==false){
  391.             prefixUrl = prefixUrl + "/";
  392.         }
  393.         prefixUrl = prefixUrl + "gestione/attivi/"+allarme.getNome()+"/image";
  394.         return AllarmiUtils.sendToAllarme(allarmiConfig, prefixUrl.toString(), log);
  395.     }
  396.     
  397.     public static void refreshActiveThreadState(ConfigurazioneAllarmeBean allarme, Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  398.         if(TipoAllarme.PASSIVO.equals(allarme.getTipoAllarme())){
  399.             // NOTA: il tipo di allarme non è modificabile.
  400.             log.debug("Allarme ["+allarme.getNome()+"] è passivo. Non contiene una immagine");
  401.             return;
  402.         }
  403.         
  404.         String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  405.         if(prefixUrl.endsWith("/")==false){
  406.             prefixUrl = prefixUrl + "/";
  407.         }
  408.         prefixUrl = prefixUrl + "gestione/attivi/"+allarme.getNome()+"/refresh";
  409.         AllarmiUtils.sendToAllarme(allarmiConfig, prefixUrl.toString(), log);
  410.     }
  411.     
  412.     public static String getActiveThreadImages(Logger log, AlarmEngineConfig allarmiConfig) throws Exception{

  414.         String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  415.         if(prefixUrl.endsWith("/")==false){
  416.             prefixUrl = prefixUrl + "/";
  417.         }
  418.         prefixUrl = prefixUrl + "gestione/attivi/image";
  419.         return AllarmiUtils.sendToAllarme(allarmiConfig, prefixUrl.toString(), log);
  420.     }
  421.     
  422.     public static void startActiveThreads(Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  423.         _manageActiveThreads(log, allarmiConfig, "start");  
  424.     }
  425.     public static void restartActiveThreads(Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  426.         _manageActiveThreads(log, allarmiConfig, "restart");    
  427.     }
  428.     public static void stopActiveThreads(Logger log, AlarmEngineConfig allarmiConfig) throws Exception{
  429.         _manageActiveThreads(log, allarmiConfig, "stop");   
  430.     }
  431.     public static void _manageActiveThreads(Logger log, AlarmEngineConfig allarmiConfig, String operazione) throws Exception{
  432.         
  433.         List<String> post_urls = new ArrayList<>();
  434.         List<String> post_contents = new ArrayList<>();
  435.                 
  436.         String prefixUrl = allarmiConfig.getActiveAlarm_serviceUrl();
  437.         if(prefixUrl.endsWith("/")==false){
  438.             prefixUrl = prefixUrl + "/";
  439.         }
  440.         prefixUrl = prefixUrl + "gestione/attivi";
  441.         post_urls.add(prefixUrl);
  442.         post_contents.add("{\"operazione\": \""+operazione+"\"}");
  443.                 
  444.         AllarmiUtils.sendToAllarmi(allarmiConfig, post_urls, post_contents, log);
  445.         
  446.     }
  447.     
  448.     public static String getTipoNomeMittente(AllarmeFiltro configurazioneFiltro) {
  449.         if (configurazioneFiltro != null && StringUtils.isNotEmpty(configurazioneFiltro.getNomeFruitore()) && !"*".equals(configurazioneFiltro.getNomeFruitore())) {
  450.             String res = configurazioneFiltro.getTipoFruitore() + "/" + configurazioneFiltro.getNomeFruitore();
  451.             return res;
  452.         }
  453.         return null;
  454.     }
  455.     
  456.     public static String getTipoNomeDestinatario(AllarmeFiltro configurazioneFiltro) {
  457.         if (configurazioneFiltro != null && StringUtils.isNotEmpty(configurazioneFiltro.getNomeErogatore()) && !"*".equals(configurazioneFiltro.getNomeErogatore())) {
  458.             String res = configurazioneFiltro.getTipoErogatore() + "/" + configurazioneFiltro.getNomeErogatore();
  459.             return res;
  460.         }
  461.         return null;
  462.     }
  463.     
  464.     
  465.     @SuppressWarnings("deprecation")
  466.     public static String getTipoNomeServizio(AllarmeFiltro configurazioneFiltro, Logger log, boolean controlloAllarmiFiltroApiSoggettoErogatore) {
  467.         if (configurazioneFiltro != null && StringUtils.isNotEmpty(configurazioneFiltro.getNomeServizio()) && !"*".equals(configurazioneFiltro.getNomeServizio())) {
  468.             
  469.             IDServizio idServizio = new IDServizio();
  470.             idServizio.setNome(configurazioneFiltro.getNomeServizio());
  471.             idServizio.setTipo(configurazioneFiltro.getTipoServizio());
  472.             idServizio.setVersione(configurazioneFiltro.getVersioneServizio());
  473.             String res;
  474.             try {
  475.                 if(controlloAllarmiFiltroApiSoggettoErogatore) {
  476.                     IDSoggetto erogatore = new IDSoggetto(configurazioneFiltro.getTipoErogatore(), configurazioneFiltro.getNomeErogatore());
  477.                     idServizio.setSoggettoErogatore(erogatore );
  478.                     
  479.                     res = NamingUtils.getLabelAccordoServizioParteSpecifica(idServizio);
  480.                 }
  481.                 else {
  482.                     res = NamingUtils.getLabelAccordoServizioParteSpecificaSenzaErogatore(idServizio );
  483.                 }
  484.                 return res;
  485.             } catch (Exception e) {
  486.                 log.error(e.getMessage(),e);
  487.             }
  488.         }
  489.         return null;
  490.     }
  491.     
  492.     public static String getAzione(AllarmeFiltro configurazioneFiltro) {
  493.         if (configurazioneFiltro != null && StringUtils.isNotEmpty(configurazioneFiltro.getAzione()) && !"*".equals(configurazioneFiltro.getAzione())) {
  494.             String res = configurazioneFiltro.getAzione();
  495.             return res;
  496.         }
  497.         return null;
  498.     }
  499.     
  500.     private static String normalizeLabelPlugin(ConfigurazioneAllarmeBean allarme){
  501.         String nome = allarme.getPlugin().getLabel();
  502.         StringBuilder bf = new StringBuilder();
  503.         
  504.         String [] tmp = nome.split(" ");
  505.         for (int i = 0; i < tmp.length; i++) {
  506.             String t = tmp[i].trim();
  507.             if(t==null || t.length()<1){
  508.                 continue;
  509.             }
  510.             if(Character.isDigit(t.charAt(0))){
  511.                 bf.append(t);
  512.             }
  513.             else{
  514.                 bf.append((t.charAt(0)+"").toUpperCase());
  515.                 if(t.length()>1){
  516.                     bf.append(t.substring(1, t.length()));
  517.                 }
  518.             }
  519.         }
  520.         
  521.         return bf.toString();
  522.     }
  523.     
  524.     public static String costruisciAliasAllarme(ConfigurazioneAllarmeBean allarme, Logger log, Context context){
  525.         
  526.         StringBuilder bf = new StringBuilder();
  527.         bf.append(normalizeLabelPlugin(allarme));
  528.         
  529.         // Ci viene Concatenato anche il Filtro (non dovrebbe più servire)
  530.         /*
  531.         AllarmeFiltro configurazioneFiltro = allarme.getFiltro();
  532.         if(AllarmiUtils.getTipoNomeMittente(configurazioneFiltro)!=null){
  533.             bf.append("_M-");
  534.             bf.append(AllarmiUtils.getTipoNomeMittente(configurazioneFiltro));
  535.         }
  536.         if(AllarmiUtils.getTipoNomeDestinatario(configurazioneFiltro)!=null){
  537.             bf.append("_D-");
  538.             bf.append(AllarmiUtils.getTipoNomeDestinatario(configurazioneFiltro));
  539.         }
  540.         if(AllarmiUtils.getTipoNomeServizio(configurazioneFiltro)!=null){
  541.             bf.append("_S-");
  542.             bf.append(AllarmiUtils.getTipoNomeServizio(configurazioneFiltro));
  543.         }
  544.         if(AllarmiUtils.getAzione(configurazioneFiltro)!=null){
  545.             bf.append("_A-");
  546.             bf.append(AllarmiUtils.getAzione(configurazioneFiltro));
  547.         }
  548.         /*/
  549.         
  550.         String nome = bf.toString();
  551.         
  552.         String p = "";
  553.         String s = "";
  554.         try{
  555.             if(allarme!=null && allarme.getPlugin()!=null && allarme.getPlugin().getClassName()!=null){
  556.                 IDynamicLoader dl = DynamicFactory.getInstance().newDynamicLoader(TipoPlugin.ALLARME, allarme.getTipo(), allarme.getPlugin().getClassName(), log);
  557.                 IAlarmProcessing alarm = (IAlarmProcessing) dl.newInstance();
  558.                 p = alarm.getAutomaticPrefixName(context);
  559.                 //System.out.println("P ["+p+"]");
  560.                 s = alarm.getAutomaticSuffixName(context);
  561.                 //System.out.println("S ["+s+"]");
  562.             }
  563.                 
  564.         }catch(Exception e){
  565.             log.error(e.getMessage(), e);
  566.         }
  567.         
  568.         if(p==null){
  569.             p = "";
  570.         }
  571.         if(s==null){
  572.             s = "";
  573.         }
  574.         return p+nome+s;
  575.     }
  576.     
  577.     public static String getLabelStato(StatoAllarme stato){
  578.         if(stato!=null){
  579.             switch (stato) {
  580.             case OK:
  581.                 return "Ok";
  582.             case WARNING:
  583.                 return "Warning";
  584.             case ERROR:
  585.                 return "Error";
  586.             }
  587.         }
  588.         return null;
  589.     }
  590. }
Created with JaCoCo 0.8.8.202204050719