InfoEsitoTransazioneFormatUtils.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.pdd.logger.info;

  23. import java.util.ArrayList;
  24. import java.util.List;

  26. import org.apache.commons.lang.StringUtils;
  27. import org.openspcoop2.core.transazioni.constants.PddRuolo;
  28. import org.openspcoop2.message.constants.MessageType;
  29. import org.openspcoop2.pdd.logger.LogLevels;
  30. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  31. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  32. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  33. import org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico;
  34. import org.openspcoop2.protocol.utils.EsitiProperties;
  35. import org.openspcoop2.utils.UtilsException;
  36. import org.openspcoop2.utils.json.JSONUtils;
  37. import org.slf4j.Logger;

  39. /**
  40.  * InfoEsitoTransazioneFormatUtils
  41.  * 
  42.  * @author Andrea Poli (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  *
  46.  */
  47. public class InfoEsitoTransazioneFormatUtils {

  49.     public static boolean isEsitoOk(Logger log, Integer esito, String protocollo){
  50.         EsitiProperties esitiProperties = null;
  51.         try{
  52.             esitiProperties = EsitiProperties.getInstanceFromProtocolName(log,protocollo);
  53.         }catch(Exception e){
  54.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  55.             return false;
  56.         }
  57.         return isEsitoOk(log, esito, esitiProperties);
  58.     }
  59.     public static boolean isEsitoOk(Logger log, Integer esito, IProtocolFactory<?> protocolFactory){
  60.         EsitiProperties esitiProperties = null;
  61.         try{
  62.             esitiProperties = EsitiProperties.getInstance(log,protocolFactory);
  63.         }catch(Exception e){
  64.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  65.             return false;
  66.         }
  67.         return isEsitoOk(log, esito, esitiProperties);
  68.     }
  69.     public static boolean isEsitoOk(Logger log, Integer esito, EsitiProperties esitiProperties){    
  70.         try{
  71.             List<Integer> list = esitiProperties.getEsitiCodeOk_senzaFaultApplicativo();
  72.             boolean res = false;
  73.             if(list!=null && !list.isEmpty()) {
  74.                 for (Integer esitoCheck : list) {
  75.                     if(esitoCheck.intValue() == esito.intValue()) {
  76.                         res = true;
  77.                         break;
  78.                     }
  79.                 }
  80.             }
  81.             //System.out.println("isEsitoOk:"+res+" (esitoChecked:"+esito+")");
  82.             return res;
  83.         }catch(Exception e){
  84.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  85.             return false;
  86.         }
  87.     }
  88.     
  89.     public static boolean isEsitoFaultApplicativo(Logger log, Integer esito, String protocollo){
  90.         EsitiProperties esitiProperties = null;
  91.         try{
  92.             esitiProperties = EsitiProperties.getInstanceFromProtocolName(log,protocollo);
  93.         }catch(Exception e){
  94.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  95.             return false;
  96.         }
  97.         return isEsitoFaultApplicativo(log, esito, esitiProperties);
  98.     }
  99.     public static boolean isEsitoFaultApplicativo(Logger log, Integer esito, IProtocolFactory<?> protocolFactory){
  100.         EsitiProperties esitiProperties = null;
  101.         try{
  102.             esitiProperties = EsitiProperties.getInstance(log,protocolFactory);
  103.         }catch(Exception e){
  104.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  105.             return false;
  106.         }
  107.         return isEsitoFaultApplicativo(log, esito, esitiProperties);
  108.     }
  109.     public static boolean isEsitoFaultApplicativo(Logger log, Integer esito, EsitiProperties esitiProperties){  
  110.         try{
  111.             List<Integer> list = esitiProperties.getEsitiCodeFaultApplicativo();
  112.             boolean res = false;
  113.             if(list!=null && !list.isEmpty()) {
  114.                 for (Integer esitoCheck : list) {
  115.                     if(esitoCheck.intValue() == esito.intValue()) {
  116.                         res = true;
  117.                         break;
  118.                     }
  119.                 }
  120.             }
  121.             //System.out.println("isEsitoOk:"+res+" (esitoChecked:"+esito+")");
  122.             return res;
  123.         }catch(Exception e){
  124.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  125.             return false;
  126.         }
  127.     }
  128.     
  129.     public static boolean isEsitoKo(Logger log, Integer esito, String protocollo){
  130.         EsitiProperties esitiProperties = null;
  131.         try{
  132.             esitiProperties = EsitiProperties.getInstanceFromProtocolName(log,protocollo);
  133.         }catch(Exception e){
  134.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  135.             return false;
  136.         }
  137.         return isEsitoKo(log, esito, esitiProperties);
  138.     }
  139.     public static boolean isEsitoKo(Logger log, Integer esito, IProtocolFactory<?> protocolFactory){
  140.         EsitiProperties esitiProperties = null;
  141.         try{
  142.             esitiProperties = EsitiProperties.getInstance(log,protocolFactory);
  143.         }catch(Exception e){
  144.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  145.             return false;
  146.         }
  147.         return isEsitoKo(log, esito, esitiProperties);
  148.     }
  149.     public static boolean isEsitoKo(Logger log, Integer esito, EsitiProperties esitiProperties){    
  150.         try{
  151.             List<Integer> list = esitiProperties.getEsitiCodeKo_senzaFaultApplicativo();
  152.             boolean res = false;
  153.             if(list!=null && !list.isEmpty()) {
  154.                 for (Integer esitoCheck : list) {
  155.                     if(esitoCheck.intValue() == esito.intValue()) {
  156.                         res = true;
  157.                         break;
  158.                     }
  159.                 }
  160.             }
  161.             //System.out.println("isEsitoOk:"+res+" (esitoChecked:"+esito+")");
  162.             return res;
  163.         }catch(Exception e){
  164.             log.error("Errore durante l'analisi dell'esito ["+esito+"]: "+e.getMessage(),e);
  165.             return false;
  166.         }
  167.     }

  169.     public static boolean isVisualizzaFault(Logger log, String fault){
  170.         boolean visualizzaMessaggio = true;

  172.         if(fault == null)
  173.             return false;

  175.         StringBuilder contenutoDocumentoStringBuilder = new StringBuilder();
  176.         String errore = FormatUtils.getTestoVisualizzabile(log, fault.getBytes(),contenutoDocumentoStringBuilder, false);
  177.         if(errore!= null)
  178.             return false;

  180.         return visualizzaMessaggio;
  181.     }

  183.     public static String getFaultPretty(Logger log, String fault, String formatoFault){
  184.         String toRet = null;
  185.         if(fault !=null) {
  186.             StringBuilder contenutoDocumentoStringBuilder = new StringBuilder();
  187.             String errore = FormatUtils.getTestoVisualizzabile(log, fault.getBytes(),contenutoDocumentoStringBuilder, true);
  188.             if(errore!= null)
  189.                 return "";

  191.             MessageType messageType= MessageType.XML;
  192.             if(StringUtils.isNotEmpty(formatoFault)) {
  193.                 messageType = MessageType.valueOf(formatoFault);
  194.             }

  196.             switch (messageType) {
  197.             case BINARY:
  198.             case MIME_MULTIPART:
  199.                 // questi due casi dovrebbero essere gestiti sopra 
  200.                 break;  
  201.             case JSON:
  202.                 JSONUtils jsonUtils = JSONUtils.getInstance(true);
  203.                 try {
  204.                     toRet = jsonUtils.toString(jsonUtils.getAsNode(fault));
  205.                 } catch (UtilsException e) {
  206.                 }
  207.                 break;
  208.             case SOAP_11:
  209.             case SOAP_12:
  210.             case XML:
  211.             default:
  212.                 toRet = FormatUtils.prettifyXml(log, fault);
  213.                 break;
  214.             }
  215.         }

  217.         if(toRet == null)
  218.             toRet = fault != null ? fault : "";

  220.         return toRet;
  221.     }


  224.     // NOTA: questo ritorna anche il fault nel caso di esito inerente
  225.     public static String getDettaglioErrore(Logger log, DatiEsitoTransazione datiEsitoTransazione, List<MsgDiagnostico> msgsParams) {

  227.         IProtocolFactory<?> protocolFactory = null;
  228.         try {
  229.             protocolFactory = datiEsitoTransazione.getProtocolFactory();
  230.         }catch(Exception e){
  231.             log.error("Errore durante il recupero del ProtocolFactory: "+e.getMessage(),e);
  232.             return ""; // non dovrebbe mai succedere
  233.         }
  234.         
  235.         if(isEsitoFaultApplicativo(log, datiEsitoTransazione.getEsito(), protocolFactory)) {

  237.             if(PddRuolo.APPLICATIVA.equals(datiEsitoTransazione.getPddRuolo())) {
  238.                 if(isVisualizzaFault(log, datiEsitoTransazione.getFaultIntegrazione())) {
  239.                     return getFaultPretty(log,datiEsitoTransazione.getFaultIntegrazione(), datiEsitoTransazione.getFormatoFaultIntegrazione());
  240.                 }
  241.                 else if(isVisualizzaFault(log, datiEsitoTransazione.getFaultCooperazione())) {
  242.                     return getFaultPretty(log,datiEsitoTransazione.getFaultCooperazione(), datiEsitoTransazione.getFormatoFaultCooperazione());
  243.                 }
  244.             }
  245.             else if(PddRuolo.DELEGATA.equals(datiEsitoTransazione.getPddRuolo())) {
  246.                 if(isVisualizzaFault(log, datiEsitoTransazione.getFaultCooperazione())) {
  247.                     return getFaultPretty(log,datiEsitoTransazione.getFaultCooperazione(), datiEsitoTransazione.getFormatoFaultCooperazione());
  248.                 }
  249.                 else if(isVisualizzaFault(log, datiEsitoTransazione.getFaultIntegrazione())) {
  250.                     return getFaultPretty(log,datiEsitoTransazione.getFaultIntegrazione(), datiEsitoTransazione.getFormatoFaultIntegrazione());
  251.                 }
  252.             }

  254.         }

  256.         // diagnostico rilevante
  257.         String erroreRilevante = getMessaggioDiagnosticoErroreRilevante(log, datiEsitoTransazione.getEsito(), protocolFactory, msgsParams, false);
  258.         if(erroreRilevante!=null) {
  259.             return erroreRilevante;
  260.         }

  262.         if(!isEsitoFaultApplicativo(log, datiEsitoTransazione.getEsito(), protocolFactory)) {

  264.             if(PddRuolo.APPLICATIVA.equals(datiEsitoTransazione.getPddRuolo())) {
  265.                 if(isVisualizzaFault(log, datiEsitoTransazione.getFaultIntegrazione())) {
  266.                     return getFaultPretty(log,datiEsitoTransazione.getFaultIntegrazione(), datiEsitoTransazione.getFormatoFaultIntegrazione());
  267.                 }
  268.                 else if(isVisualizzaFault(log, datiEsitoTransazione.getFaultCooperazione())) {
  269.                     return getFaultPretty(log,datiEsitoTransazione.getFaultCooperazione(), datiEsitoTransazione.getFormatoFaultCooperazione());
  270.                 }
  271.             }
  272.             else if(PddRuolo.DELEGATA.equals(datiEsitoTransazione.getPddRuolo())) {
  273.                 if(isVisualizzaFault(log, datiEsitoTransazione.getFaultCooperazione())) {
  274.                     return getFaultPretty(log,datiEsitoTransazione.getFaultCooperazione(), datiEsitoTransazione.getFormatoFaultCooperazione());
  275.                 }
  276.                 else if(isVisualizzaFault(log, datiEsitoTransazione.getFaultIntegrazione())) {
  277.                     return getFaultPretty(log,datiEsitoTransazione.getFaultIntegrazione(), datiEsitoTransazione.getFormatoFaultIntegrazione());
  278.                 }
  279.             }

  281.         }

  283.         return null;
  284.     }

  286.     public static String getMessaggioDiagnosticoErroreRilevante(Logger log, Integer esito, IProtocolFactory<?> protocolFactory, List<MsgDiagnostico> msgsParams, boolean forceIgnoreWarning) {
  287.         
  288.         // Esito
  289.         EsitiProperties esitiProperties = null;
  290.         EsitoTransazioneName esitoTransactionName = null;
  291.         try {
  292.             esitiProperties = EsitiProperties.getInstance(log, protocolFactory);
  293.             esitoTransactionName = esitiProperties.getEsitoTransazioneName(esito);
  294.         }catch(Exception e){
  295.             log.error("Errore durante il recupero dell'esito della transazione: "+e.getMessage(),e);
  296.             return ""; // non dovrebbe mai succedere
  297.         }
  298.         
  299.         List<MsgDiagnostico> msgs = null;
  300.         if(msgsParams!=null) {
  301.             msgs = new ArrayList<MsgDiagnostico>();
  302.             if(!msgsParams.isEmpty()) {
  303.                 for (MsgDiagnostico msgDiagnostico : msgsParams) {
  304.                     if(msgDiagnostico.getSeverita()<=LogLevels.SEVERITA_ERROR_INTEGRATION) {
  305.                         msgs.add(msgDiagnostico);
  306.                     }
  307.                 }
  308.             }
  309.         }
  310.         
  311.         try {
  312.             StringBuilder sb = new StringBuilder();
  313.             StringBuilder erroreConnessone = new StringBuilder();
  314.             StringBuilder erroreSegnalaGenerazioneRispostaErrore = new StringBuilder();
  315.             if(msgs!=null && !msgs.isEmpty()) {
  316.                 for (MsgDiagnostico msgDiagnostico : msgs) {
  317.                     String codice = msgDiagnostico.getCodice();

  319.                     if(isEsitoKo(log, esito, protocolFactory) || forceIgnoreWarning) {
  320.                         // salto gli errori 'warning'
  321.                         if(MsgDiagnosticiProperties.MSG_DIAGNOSTICI_WARNING.contains(codice)) {
  322.                             continue;
  323.                         }
  324.                     }

  326.                     if(EsitoTransazioneName.isErroreRisposta(esitoTransactionName) && MsgDiagnosticiProperties.MSG_DIAGNOSTICI_ERRORE_CONNETTORE.contains(codice)) {
  327.                         if(erroreConnessone.length()>0) {
  328.                             erroreConnessone.append("\n");
  329.                         }
  330.                         erroreConnessone.append(msgDiagnostico.getMessaggio());
  331.                     }
  332.                     else if(MsgDiagnosticiProperties.MSG_DIAGNOSTICI_SEGNALA_GENERATA_RISPOSTA_ERRORE.contains(codice)) {
  333.                         if(erroreSegnalaGenerazioneRispostaErrore.length()>0) {
  334.                             erroreSegnalaGenerazioneRispostaErrore.append("\n");
  335.                         }
  336.                         erroreSegnalaGenerazioneRispostaErrore.append(msgDiagnostico.getMessaggio());
  337.                     }
  338.                     else {
  339.                         if(sb.length()>0) {
  340.                             sb.append("\n");
  341.                         }
  342.                         sb.append(msgDiagnostico.getMessaggio());

  344.                         break; // serializzo solo il primo diagnostico
  345.                     }
  346.                 }
  347.             }
  348.             if(sb.length()>0) {
  349.                 return sb.toString();
  350.             }
  351.             if(erroreConnessone.length()>0) {
  352.                 return erroreConnessone.toString();
  353.             }
  354.             if(erroreSegnalaGenerazioneRispostaErrore.length()>0) {
  355.                 return erroreSegnalaGenerazioneRispostaErrore.toString();
  356.             }

  358.         }catch(Exception e){
  359.             log.error("Errore durante il recupero dell'errore: "+e.getMessage(),e);
  360.         }
  361.         
  362.         return null;
  363.     }
  364.     
  365.     public static String getMessaggioDiagnosticoWarning(Logger log, Integer esito, IProtocolFactory<?> protocolFactory, List<MsgDiagnostico> msgsParams) {
  366.         
  367.         List<MsgDiagnostico> msgs = null;
  368.         if(msgsParams!=null) {
  369.             msgs = new ArrayList<MsgDiagnostico>();
  370.             if(!msgsParams.isEmpty()) {
  371.                 for (MsgDiagnostico msgDiagnostico : msgsParams) {
  372.                     if(msgDiagnostico.getSeverita()<=LogLevels.SEVERITA_ERROR_INTEGRATION) {
  373.                         msgs.add(msgDiagnostico);
  374.                     }
  375.                 }
  376.             }
  377.         }
  378.         
  379.         try {
  380.             StringBuilder sb = new StringBuilder();
  381.             if(msgs!=null && !msgs.isEmpty()) {
  382.                 for (MsgDiagnostico msgDiagnostico : msgs) {
  383.                     String codice = msgDiagnostico.getCodice();

  385.                     if(MsgDiagnosticiProperties.MSG_DIAGNOSTICI_WARNING.contains(codice)) {
  386.                         if(sb.length()>0) {
  387.                             sb.append("\n");
  388.                         }
  389.                         sb.append(msgDiagnostico.getMessaggio());
  390.                     }
  391.                     
  392.                 }
  393.             }
  394.             if(sb.length()>0) {
  395.                 return sb.toString();
  396.             }

  398.         }catch(Exception e){
  399.             log.error("Errore durante il recupero dell'errore: "+e.getMessage(),e);
  400.         }
  401.         
  402.         return null;
  403.     }
  404. }
Created with JaCoCo 0.8.8.202204050719