SoapUtils.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.  */



  23. package org.openspcoop2.message.soap;


  26. import java.io.ByteArrayOutputStream;
  27. import java.util.ArrayList;
  28. import java.util.Enumeration;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Locale;

  33. import javax.mail.internet.ContentType;
  34. import javax.mail.internet.ParseException;
  35. import javax.xml.namespace.QName;
  36. import javax.xml.soap.Detail;
  37. import javax.xml.soap.MessageFactory;
  38. import javax.xml.soap.MimeHeader;
  39. import javax.xml.soap.MimeHeaders;
  40. import javax.xml.soap.SOAPBody;
  41. import javax.xml.soap.SOAPElement;
  42. import javax.xml.soap.SOAPEnvelope;
  43. import javax.xml.soap.SOAPException;
  44. import javax.xml.soap.SOAPFactory;
  45. import javax.xml.soap.SOAPFault;
  46. import javax.xml.soap.SOAPHeader;
  47. import javax.xml.soap.SOAPHeaderElement;
  48. import javax.xml.soap.SOAPMessage;
  49. import javax.xml.soap.SOAPPart;
  50. import javax.xml.soap.Text;

  52. import org.openspcoop2.message.OpenSPCoop2Message;
  53. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  54. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  55. import org.openspcoop2.message.constants.Costanti;
  56. import org.openspcoop2.message.constants.MessageRole;
  57. import org.openspcoop2.message.constants.MessageType;
  58. import org.openspcoop2.message.constants.ServiceBinding;
  59. import org.openspcoop2.message.exception.MessageException;
  60. import org.openspcoop2.message.exception.MessageNotSupportedException;
  61. import org.openspcoop2.message.exception.ParseExceptionUtils;
  62. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  63. import org.openspcoop2.message.utils.MessageUtilities;
  64. import org.openspcoop2.message.xml.MessageXMLUtils;
  65. import org.openspcoop2.utils.NameValue;
  66. import org.openspcoop2.utils.Utilities;
  67. import org.openspcoop2.utils.transport.TransportRequestContext;
  68. import org.openspcoop2.utils.transport.http.HttpConstants;
  69. import org.openspcoop2.utils.xml.PrettyPrintXMLUtils;
  70. import org.slf4j.Logger;
  71. import org.w3c.dom.Element;
  72. import org.w3c.dom.Node;


  75. /**
  76.  * Libreria contenente metodi utili per la gestione della busta Soap.
  77.  *
  78.  *
  79.  * @author Poli Andrea (apoli@link.it)
  80.  * @author $Author$
  81.  * @version $Rev$, $Date$
  82.  */

  84. public class SoapUtils {

  86.     // SAX - TRANSFORMER
  87.     
  88.     public static  MessageException buildMessageException(String prefix, Throwable t) {
  89.         MessageException meSAXParser = null;
  90.         String msgSAXParser = null;
  91.         if(Utilities.existsInnerInstanceException(t, org.xml.sax.SAXParseException.class)) {
  92.             Throwable tExists = Utilities.getInnerInstanceException(t, org.xml.sax.SAXParseException.class, false);
  93.             if(tExists!=null) {
  94.                 msgSAXParser = tExists.getMessage();
  95.                 meSAXParser = new MessageException(prefix+tExists.getMessage(),t);
  96.             }
  97.         }
  98.         
  99.         // cerco TransformerException che contiene SAX Parser perchè almeno c'è anche l'indicazione sulla posizione dell'errore (riga e colonna)
  100.         if(msgSAXParser!=null && Utilities.existsInnerInstanceException(t, javax.xml.transform.TransformerException.class)) {
  101.             Throwable tExists = Utilities.getInnerInstanceException(t, javax.xml.transform.TransformerException.class, false);
  102.             if(tExists!=null && tExists.getMessage()!=null && tExists.getMessage().contains(msgSAXParser)) {
  103.                 return new MessageException(prefix+tExists.getMessage(),t);
  104.             }
  105.         }
  106.         
  107.         if(meSAXParser!=null) {
  108.             return meSAXParser;
  109.         }
  110.         
  111.         // Altrimenti cerco org.xml.sax.SAXException
  112.         MessageException meSAXException = null;
  113.         String msgSAXException = null;
  114.         if(Utilities.existsInnerInstanceException(t, org.xml.sax.SAXException.class)) {
  115.             Throwable tExists = Utilities.getInnerInstanceException(t, org.xml.sax.SAXException.class, false);
  116.             if(tExists!=null) {
  117.                 msgSAXException = tExists.getMessage();
  118.                 meSAXException = new MessageException(prefix+tExists.getMessage(),t);
  119.             }
  120.         }
  121.         
  122.         // cerco TransformerException che contiene SAX Exception perchè almeno c'è anche l'indicazione sulla posizione dell'errore (riga e colonna)
  123.         if(msgSAXException!=null && Utilities.existsInnerInstanceException(t, javax.xml.transform.TransformerException.class)) {
  124.             Throwable tExists = Utilities.getInnerInstanceException(t, javax.xml.transform.TransformerException.class, false);
  125.             if(tExists!=null && tExists.getMessage()!=null && tExists.getMessage().contains(msgSAXException)) {
  126.                 return new MessageException(prefix+tExists.getMessage(),t);
  127.             }
  128.         }
  129.         
  130.         if(meSAXException!=null) {
  131.             return meSAXException;
  132.         }
  133.         
  134.         return new MessageException(t.getMessage(),t);
  135.     }
  136.     
  137.     
  138.     
  139.     // SOAP FACTORY
  140.     
  141.     public static SOAPFactory getSoapFactory(OpenSPCoop2MessageFactory messageFactory, MessageType messageType) throws MessageNotSupportedException {
  142.         if(MessageType.SOAP_11.equals(messageType))
  143.             return messageFactory.getSoapFactory11();
  144.         else if(MessageType.SOAP_12.equals(messageType))
  145.             return messageFactory.getSoapFactory12();
  146.         else
  147.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  148.     }
  149.     public static MessageFactory getMessageFactory(OpenSPCoop2MessageFactory messageFactory) throws SOAPException {
  150.         return messageFactory.getSoapMessageFactory();
  151.     }
  152.         
  153.     
  154.     // SOAP Fault String 'Locale' for LANG
  155.     
  156.     private static Locale soapFaultStringLocale = null;
  157.     public static void setSoapFaultStringLocale(Locale soapFaultStringLocale) {
  158.         SoapUtils.soapFaultStringLocale = soapFaultStringLocale;
  159.     }
  160.     public static void setFaultString(SOAPFault fault, String faultString) throws SOAPException {
  161.          setFaultString(fault, faultString, null);
  162.     }
  163.     public static void setFaultString(SOAPFault fault, String faultString, Locale lParam) throws SOAPException {
  164.         if(lParam!=null) {
  165.             fault.setFaultString(faultString, lParam);
  166.         }
  167.         else if(soapFaultStringLocale!=null) {
  168.             fault.setFaultString(faultString, soapFaultStringLocale);
  169.         }
  170.         else {
  171.             fault.setFaultString(faultString);
  172.         }
  173.     }
  174.     
  175.     
  176.     
  177.     
  178.     // SOAP getElement
  179.     
  180.     public static SOAPElement getFirstSOAPElement(SOAPElement element) {
  181.         if(element!=null) {
  182.             Iterator<?> it = element.getChildElements();
  183.             while (it.hasNext()){
  184.                 Node tmp = (Node) it.next();
  185.                 if(tmp instanceof SOAPElement) { 
  186.                     return (SOAPElement) tmp;
  187.                 }
  188.             }
  189.         }
  190.         return null;
  191.     }
  192.     
  193.     
  194.     
  195.     
  196.     // SOAP Content Type
  197.     
  198.     public static String getContentType(SOAPMessage msg) {
  199.         if(msg.getMimeHeaders()==null) {
  200.             return null;
  201.         }
  202.         String[] values = msg.getMimeHeaders().getHeader(HttpConstants.CONTENT_TYPE);
  203.         if (values == null || values.length<=0) {
  204.             return getContentType(msg.getMimeHeaders());
  205.         }
  206.         else {
  207.             return values[0];
  208.         }
  209.     }
  210.     
  211.     public static String getContentType(MimeHeaders mhs) {
  212.         if(mhs!=null) {
  213.             Iterator<MimeHeader> itMhs = mhs.getAllHeaders();
  214.             if(itMhs!=null) {
  215.                 while (itMhs.hasNext()) {
  216.                     MimeHeader mimeHeader = (MimeHeader) itMhs.next();
  217.                     if(mimeHeader!=null && mimeHeader.getName()!=null && HttpConstants.CONTENT_TYPE.toLowerCase().equals(mimeHeader.getName().toLowerCase())) {
  218.                         return mimeHeader.getValue();
  219.                     }
  220.                 }
  221.             }
  222.         }
  223.         return null;
  224.     }
  225.     
  226.     
  227.     
  228.     
  229.     // SOAPAction
  230.     
  231.     public static String getSoapAction(TransportRequestContext transportRequestContext, MessageType messageType, String contentType) throws MessageException, MessageNotSupportedException{

  233.         if(MessageType.SOAP_11.equals(messageType)){
  234.         
  235.             if(transportRequestContext.getHeaders()==null || transportRequestContext.getHeaders().size()<=0){
  236.                 throw new MessageException("Header http '"+Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION+"' non valorizzato (nessun header di trasporto trovato)");
  237.             }
  238.             
  239.             Iterator<String> enTrasporto = transportRequestContext.getHeaders().keySet().iterator();
  240.             while(enTrasporto.hasNext()){
  241.                 String nomeProperty = (String)enTrasporto.next();
  242.                 if(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION.equalsIgnoreCase(nomeProperty)){
  243.                     //System.out.println("TROVATO SOAP ACTION: "+req.getHeader(nomeProperty));
  244.                     String soapAction = transportRequestContext.getHeaderFirstValue(nomeProperty);
  245.                     if(soapAction==null){
  246.                         throw new MessageException("Header http '"+Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION+"' non valorizzato (null)");
  247.                     }
  248.                     soapAction = soapAction.trim();
  249.                     if(soapAction.startsWith("\"")){
  250.                         if(!soapAction.endsWith("\"")){
  251.                             throw new MessageException("Header http '"+Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION+"' non valorizzato correttamente (action quotata? Non è stato trovato il carattere di chiusura \" ma è presente quello di apertura)");
  252.                         }   
  253.                     }
  254.                     if(soapAction.endsWith("\"")){
  255.                         if(!soapAction.startsWith("\"")){
  256.                             throw new MessageException("Header http '"+Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION+"' non valorizzato correttamente (action quotata? Non è stato trovato il carattere di apertura \" ma è presente quello di chiusura)");
  257.                         }   
  258.                     }
  259.                     return soapAction;
  260.                 }
  261.             }
  262.     
  263.             throw new MessageException("Header http '"+Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION+"' non presente");
  264.             
  265.         }
  266.         else if(MessageType.SOAP_12.equals(messageType)){
  267.             // The SOAP 1.1 mandatory SOAPAction HTTP header has been removed in SOAP 1.2. In its place is an optional action parameter on the application/soap+xml media type.
  268.             ContentType ct = null;
  269.             try{
  270.                 ct = new ContentType(contentType);
  271.             }catch(Exception e){
  272.                 throw new MessageException("Content-Type '"+contentType+"' non valorizzato correttamente: "+e.getMessage(),e);
  273.             }
  274.             if(ct.getParameterList()!=null && ct.getParameterList().size()>0){
  275.                 Enumeration<?> names = ct.getParameterList().getNames();
  276.                 while (names.hasMoreElements()) {
  277.                     String name = (String) names.nextElement();
  278.                     if(Costanti.SOAP12_OPTIONAL_CONTENT_TYPE_PARAMETER_SOAP_ACTION.equals(name)){
  279.                         return ct.getParameterList().get(name);
  280.                     }   
  281.                 }
  282.             }
  283.             
  284.             return null;
  285.         }
  286.         else{
  287.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  288.         }
  289.         
  290.     }
  291.     
  292.     public static void checkSoapActionQuotedString(String soapAction,MessageType messageType) throws MessageException, MessageNotSupportedException{
  293.         if(MessageType.SOAP_11.equals(messageType)){
  294.             // WS-I BasicProfile 1.1: R1109   The value of the SOAPAction HTTP header field in a HTTP request MESSAGE MUST be a quoted string.
  295.             if(!soapAction.startsWith("\"") || !soapAction.endsWith("\"")){
  296.                 throw new MessageException("Header http '"+Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION+"' valorizzato tramite una stringa non quotata (WSI-BP-1.1 R1109)");
  297.             }
  298.         }
  299.         else{
  300.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  301.         }
  302.     }
  303.     
  304.     
  305.     
  306.     
  307.     
  308.     // SOAP HEADER E MUST UNDERSTAND
  309.     
  310.     public static String getSoapActor(SOAPHeaderElement headerElement, MessageType messageType) throws MessageNotSupportedException{
  311.         
  312.         if(MessageType.SOAP_11.equals(messageType)){
  313.             return headerElement.getActor();
  314.         }
  315.         else if(MessageType.SOAP_12.equals(messageType)){
  316.             return headerElement.getRole();
  317.         }
  318.         else{
  319.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  320.         }
  321.     }
  322.     
  323.     public static boolean checkMustUnderstandHeaderElement(MessageType messageType, SOAPHeader header,List<NameValue> filtri, StringBuilder bfErrorParam) throws MessageException {
  324.         
  325.         
  326.         StringBuilder bfError = new StringBuilder();
  327.         try{
  328.             java.util.Iterator<?> headers = header.getChildElements();
  329.             while (headers.hasNext()) {
  330.                 Object element = headers.next();
  331.                 if(!(element instanceof SOAPHeaderElement)){
  332.                     continue;
  333.                 }
  334.                 
  335.                 SOAPHeaderElement elementHeader = (SOAPHeaderElement) element;
  336.                 
  337.                 String actor = SoapUtils.getSoapActor(elementHeader, messageType);
  338.                 
  339.                 // Prendo gli headers con MustUnderstand="1" senza Actor
  340.                 if(actor==null && elementHeader.getMustUnderstand()==true){
  341.                     boolean checked = false;
  342.                     if(filtri!=null && filtri.size()>0){
  343.                         for (NameValue nameValue : filtri) {
  344.                             String localName = nameValue.getName();
  345.                             String namespaceURI = nameValue.getValue();
  346.                             if(localName.equals(elementHeader.getLocalName()) && namespaceURI.equals(elementHeader.getNamespaceURI())){
  347.                                 // Ok si bypassa.
  348.                                 checked = true;
  349.                                 break;
  350.                             }
  351.                         }
  352.                     }
  353.                     
  354.                     // Controllo se abbiamo bypassato l'header
  355.                     if(!checked){
  356.                         // Abbiamo un MustUnderstand="1" senza Actor che non appare nella lista da Bypassare!

  358.                         if(bfError.length()>0){
  359.                             bfError.append(", ");
  360.                         }
  361.                         bfError.append("{").append(elementHeader.getNamespaceURI()).append("}").append(elementHeader.getLocalName());
  362.                         
  363.                     }
  364.                 }
  365.             }
  366.         }catch(java.lang.Exception e) {
  367.             
  368.             Throwable t = ParseExceptionUtils.getParseException(e);
  369.             if(t!=null){
  370.                 throw new MessageException(e);
  371.             }
  372.             
  373.             throw new MessageException("Riscontrato errore durante l'applicazione del bypassMustUnderstandHeader: "+e.getMessage(),e);
  374.         }  
  375.         
  376.         if(bfError.length()>0){
  377.             bfErrorParam.append(bfError.toString());
  378.         }
  379.         return bfError.length()<=0;
  380.     }
  381.     
  382.     
  383.     
  384.     
  385.     // SOAP With Attachments
  386.     
  387.     public static void addSWAStartParameterIfNotPresent(OpenSPCoop2Message message) throws MessageException {
  388.         addSWAStartParameterIfNotPresent(message, false, false);
  389.     }
  390.     public static void addSWAStartParameterIfNotPresent(OpenSPCoop2Message message, boolean addOnlyIfExistsContentIdRootPart) throws MessageException {
  391.         addSWAStartParameterIfNotPresent(message, addOnlyIfExistsContentIdRootPart, false);
  392.     }
  393.     public static void addSWAStartParameterIfNotPresent(OpenSPCoop2Message message, boolean addOnlyIfExistsContentIdRootPart, boolean forceAddStartParameter) throws MessageException {
  394.         if(message!=null && ServiceBinding.SOAP.equals(message.getServiceBinding())) {
  395.             
  396.             try {
  397.             
  398.                 OpenSPCoop2SoapMessage soapMsg = message.castAsSoap();
  399.                 if(!soapMsg.hasAttachments()) {
  400.                     return;
  401.                 }
  402.                 SOAPPart part = soapMsg.getSOAPPart();
  403.                 if(part==null) {
  404.                     throw new MessageException("SOAPPart is null?");
  405.                 }
  406.                 
  407.                 String [] idOld = part.getMimeHeader(HttpConstants.CONTENT_ID);
  408.                 String id = null;
  409.                 if(idOld!=null && idOld.length>0) {
  410.                     id = idOld[0];
  411.                 }
  412.                 addSWAStartParameterIfNotPresentEngine(soapMsg, part,
  413.                         addOnlyIfExistsContentIdRootPart, forceAddStartParameter,
  414.                         id);
  415.                 
  416.             }catch(Exception t) {
  417.                 throw new MessageException(t.getMessage(),t);
  418.             }
  419.             
  420.         }
  421.     }
  422.     private static void addSWAStartParameterIfNotPresentEngine(OpenSPCoop2SoapMessage soapMsg, SOAPPart part,
  423.             boolean addOnlyIfExistsContentIdRootPart, boolean forceAddStartParameter,
  424.             String id) throws MessageException, MessageNotSupportedException, ParseException {
  425.         /**System.out.println("=== SOAP id PART: "+id);*/
  426.         if(id==null) {
  427.             if(addOnlyIfExistsContentIdRootPart) {
  428.                 /**System.out.println("ContentId non esistente e creazione non richiesta");*/
  429.                 return;
  430.             }
  431.             id = soapMsg.createContentID("http://govway.org");
  432.             part.addMimeHeader("Content-Id", id);
  433.             /**System.out.println("=== ADD id PART ");*/
  434.         }
  435.         String cType = soapMsg.getContentType();
  436.         ContentType contentType = new ContentType(cType);
  437.         String startParam = contentType.getParameter(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_START);
  438.         /**System.out.println("startParam PART: "+startParam);*/
  439.         if(startParam==null || forceAddStartParameter) {
  440.             /**System.out.println("ADD START PARAM");*/
  441.             soapMsg.addContentTypeParameter(HttpConstants.CONTENT_TYPE_MULTIPART_PARAMETER_START, id);
  442.         }
  443.     }
  444.     
  445.     
  446.     
  447.     
  448.     // GET NODES e ELEMENT
  449.     
  450.     public static List<Node> getNotEmptyChildNodes(OpenSPCoop2MessageFactory messageFactory, Node e){
  451.         return getNotEmptyChildNodes(messageFactory, e, true);
  452.     }
  453.     public static List<Node> getNotEmptyChildNodes(OpenSPCoop2MessageFactory messageFactory, Node e, boolean consideraTextNotEmptyAsNode){
  454.         return MessageXMLUtils.getInstance(messageFactory).getNotEmptyChildNodes(e, consideraTextNotEmptyAsNode);
  455.     }
  456.     
  457.     public static Node getFirstNotEmptyChildNode(OpenSPCoop2MessageFactory messageFactory, Node e){
  458.         return getFirstNotEmptyChildNode(messageFactory, e, true);
  459.     }
  460.     public static Node getFirstNotEmptyChildNode(OpenSPCoop2MessageFactory messageFactory, Node e, boolean consideraTextNotEmptyAsNode){
  461.         return MessageXMLUtils.getInstance(messageFactory).getFirstNotEmptyChildNode(e, consideraTextNotEmptyAsNode);
  462.     }
  463.     
  464.     public static List<SOAPElement> getNotEmptyChildSOAPElement(SOAPElement e){
  465.         List<SOAPElement> vec = new ArrayList<SOAPElement>();
  466.         Iterator<?> soapElements = e.getChildElements();
  467.         while (soapElements.hasNext()) {
  468.             Object soapElement = soapElements.next();
  469.             if(soapElement instanceof SOAPElement){
  470.                 vec.add((SOAPElement)soapElement);
  471.             }
  472.         }
  473.         return vec;
  474.     }
  475.     
  476.     public static SOAPElement getNotEmptyFirstChildSOAPElement(SOAPElement e){
  477.         Iterator<?> soapElements = e.getChildElements();
  478.         while (soapElements.hasNext()) {
  479.             Object soapElement = soapElements.next();
  480.             if(soapElement instanceof SOAPElement){
  481.                 return (SOAPElement)soapElement;
  482.             }
  483.         }
  484.         return null;
  485.     }

  487.     
  488.     
  489.     // VERSION, NAMESPACE e CONTENT-TYPE
  490.     
  491.     public static String getSoapEnvelopeNS(MessageType messageType) throws MessageNotSupportedException {
  492.         if(MessageType.SOAP_11.equals(messageType))
  493.             return Costanti.SOAP_ENVELOPE_NAMESPACE;
  494.         else if(MessageType.SOAP_12.equals(messageType))
  495.             return Costanti.SOAP12_ENVELOPE_NAMESPACE;
  496.         else
  497.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  498.     }
  499.     
  500.     public static String getSoapContentTypeForMessageWithoutAttachments(MessageType messageType) throws MessageNotSupportedException{
  501.         if(MessageType.SOAP_11.equals(messageType) || MessageType.SOAP_12.equals(messageType))
  502.             return MessageUtilities.getDefaultContentType(messageType);
  503.         else
  504.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  505.     }
  506.     
  507.     public static MessageType getSOAPVersion(Logger log, byte [] xml){
  508.         // La posizione dovrebbe garantirmi il giusto namespace
  509.         // Nel caso all'interno del body viene usato l'altro.
  510.         String s = new String(xml);
  511.         if( (s.contains("<Envelope") || s.contains(":Envelope") ) ){
  512.             int indexOfSoap11 = s.indexOf(Costanti.SOAP_ENVELOPE_NAMESPACE);
  513.             int indexOfSoap12 = s.indexOf(Costanti.SOAP12_ENVELOPE_NAMESPACE);
  514.             if(indexOfSoap11>0 && indexOfSoap12>0){
  515.                 if(indexOfSoap11<indexOfSoap12){
  516.                     return MessageType.SOAP_11;
  517.                 }
  518.                 else{
  519.                     return MessageType.SOAP_12;
  520.                 }
  521.             }
  522.             else if(indexOfSoap11>0){
  523.                 return MessageType.SOAP_11;
  524.             }
  525.             else if(indexOfSoap12>0){
  526.                 return MessageType.SOAP_12;
  527.             }
  528.         }
  529.         return null;
  530.     }
  531.     
  532.     public static boolean checkSOAPEnvelopeNamespace(OpenSPCoop2SoapMessage message, MessageType messageType) throws MessageException, MessageNotSupportedException{
  533.         try {
  534.             OpenSPCoop2MessageSoapStreamReader reader = message.getSoapReader();
  535.             String envelopeNamespace = null;
  536.             if(reader!=null) {
  537.                 envelopeNamespace = reader.getNamespace();
  538.             }
  539.             if(envelopeNamespace==null) {
  540.                 SOAPPart soapPart = message.getSOAPPart();
  541.                 if(soapPart!=null) {
  542.                     SOAPEnvelope envelope = soapPart.getEnvelope();
  543.                     if(envelope!=null) {
  544.                         envelopeNamespace = envelope.getNamespaceURI();
  545.                     }
  546.                 }
  547.             }
  548.             
  549.             if(envelopeNamespace==null && message instanceof AbstractOpenSPCoop2Message_soap_impl) {
  550.                 boolean hasContent = ((AbstractOpenSPCoop2Message_soap_impl<?>)message).hasContent();
  551.                 if(!hasContent) {
  552.                     throw new MessageException("Invalid empty message");
  553.                 }
  554.             }
  555.             
  556.             if(messageType.equals(MessageType.SOAP_11) &&  Costanti.SOAP_ENVELOPE_NAMESPACE.equals(envelopeNamespace)) {
  557.                 return true;
  558.             }
  559.             
  560.             if(messageType.equals(MessageType.SOAP_12) &&  Costanti.SOAP12_ENVELOPE_NAMESPACE.equals(envelopeNamespace)) {
  561.                 return true;
  562.             }
  563.             
  564.             return false;

  566.         } catch (Exception ex) {
  567.             
  568.             Throwable t = ParseExceptionUtils.getParseException(ex);
  569.             if(t!=null){
  570.                 throw new MessageException(ex);
  571.             }
  572.             
  573.             throw new MessageException(ex.getMessage(),ex);
  574.         }   
  575.     }

  577.     
  578.     
  579.     // NODE UTILS
  580.     
  581.     public static boolean matchLocalName(OpenSPCoop2MessageFactory messageFactory, Node nodo,String nodeName,String prefix,String namespace){
  582.         return MessageXMLUtils.getInstance(messageFactory).matchLocalName(nodo, nodeName, prefix, namespace);
  583.     } 
  584.     
  585.     public static Node getAttributeNode(OpenSPCoop2MessageFactory messageFactory, Node node,String attributeName){
  586.         return MessageXMLUtils.getInstance(messageFactory).getAttributeNode(node, attributeName);
  587.     }
  588.     public static Node getQualifiedAttributeNode(OpenSPCoop2MessageFactory messageFactory, Node node,String attributeName,String namespace){
  589.         return MessageXMLUtils.getInstance(messageFactory).getQualifiedAttributeNode(node, attributeName, namespace);
  590.     }
  591.     
  592.     
  593.     // EQUALS
  594.     
  595.     public static void equalsSoapElements(SOAPElement element1,SOAPElement element2,boolean checkTextComment) throws MessageException{
  596.         try{
  597.             _equalsSoapElements(element1, element2, new ArrayList<>(),checkTextComment);
  598.         }catch(Exception e){
  599.             try{
  600.                 String soapReq = PrettyPrintXMLUtils.prettyPrintWithTrAX(element1);
  601.                 String soapRes = PrettyPrintXMLUtils.prettyPrintWithTrAX(element2);
  602.                 throw new MessageException("Element1 ["+soapReq+"] risulta differente da Element2 ["+soapRes+"] (motivo:"+e.getMessage()+")",e);
  603.             }catch(Exception eInternal){
  604.                 throw new MessageException(eInternal.getMessage(),eInternal);
  605.             }
  606.         }
  607.     }

  609.     private static String _getQualifiedName(QName attr){
  610.         if(attr.getNamespaceURI()!=null){
  611.             return "{"+ attr.getNamespaceURI()+" }"+attr.getLocalPart();
  612.         }
  613.         else{
  614.             return attr.getLocalPart();
  615.         }
  616.     }
  617.     
  618.     private static void _equalsSoapElements(SOAPElement el1,SOAPElement el2,List<String> namespacePrefixEl1,boolean checkTextComment) throws MessageException{
  619.         
  620.         /**************** controllo nome del nodo *****************************/
  621.         if(!el1.getNodeName().equals(el2.getNodeName())){
  622.             //System.out.println("NOME DIVERSO");
  623.             throw new MessageException("Node1 possiede un nome ["+el1.getNodeName()+"] differente dal nome del Node2 ["+el2.getNodeName()+"]");
  624.         }
  625.         
  626.         
  627.         Iterator<?> it=el1.getAllAttributesAsQNames();
  628.         Iterator<?> it2=el2.getAllAttributesAsQNames();
  629.         List <String>vet=new ArrayList<>();
  630.         List <String>vet2=new ArrayList<>();
  631.         /**************** controllo se gli attributi sono uguali*****************************/
  632.         while(it.hasNext()){
  633.             if(!it2.hasNext()){
  634.                 //System.out.println("ATTR 1");
  635.                 throw new MessageException("Node1 ["+el1.getNodeName()+"] possiede degli attributi, mentre nel node2 ["+el2.getNodeName()+"] non ve ne sono");
  636.             }
  637.             //Attributes att=(Attributes)it.next();
  638.             QName attr1 = ((QName) it.next());
  639.             vet.add( _getQualifiedName(attr1) );
  640.             
  641.             QName attr2 = ((QName) it2.next());
  642.             vet2.add( _getQualifiedName(attr2) );
  643.             
  644.         }
  645.         if(it2.hasNext()){
  646.             //System.out.println("ATTR 2");
  647.             throw new MessageException("Node2 ["+el2.getNodeName()+"] possiede piu' attributi del Node1 ["+el1.getNodeName()+"]");
  648.         }
  649.         if(!vet.containsAll(vet2)){
  650.             //System.out.println("ATTR 3");
  651.             
  652.             StringBuilder bfNode1 = new StringBuilder();
  653.             for (int i = 0; i < vet.size(); i++) {
  654.                 if(i>0){
  655.                     bfNode1.append(",");
  656.                 }
  657.                 bfNode1.append(vet.get(i));
  658.             }
  659.             
  660.             StringBuilder bfNode2 = new StringBuilder();
  661.             for (int i = 0; i < vet2.size(); i++) {
  662.                 if(i>0){
  663.                     bfNode2.append(",");
  664.                 }
  665.                 bfNode2.append(vet2.get(i));
  666.             }
  667.             
  668.             throw new MessageException("Node1 ["+el1.getNodeName()+"] e Node2 ["+el2.getNodeName()+"] non hanno gli stessi attributi. Attributi("+vet.size()+") di Node1: "+bfNode1+ " . Attributi("+vet2.size()+") di Node2: "+bfNode2);
  669.         }


  672.         for(int i=0;i<vet.size();i++){
  673.             String value=vet.get(i);
  674.             if(!el1.getAttribute(value).equals(el2.getAttribute(value))){
  675.                 throw new MessageException("L'attributo ["+value+"] di Node1 ["+el1.getNodeName()+"] possiede un valore ("+
  676.                             el1.getAttribute(value)+") differente dal valore presente nello stesso attributo nel Node2 ["+el2.getNodeName()+"] (valore:"+el2.getAttribute(value)+")");
  677.             }
  678.         }

  680.         /***************************** Namespace URI del nodo ********************************/
  681.         String str1=el1.getNamespaceURI();
  682.         String str2=el2.getNamespaceURI();
  683.        // System.out.println("el1 -- il namespace Uri del nodo e' "+str1);
  684.         //System.out.println("el2 -- il namespace Uri del nodo e' "+str2);
  685.         boolean namespaceIdentico = false;
  686.         if(str1!=null && str2!=null){
  687.             namespaceIdentico = str1.equals(str2);
  688.         }
  689.         else if(str1==null && str2==null){
  690.             namespaceIdentico = true;
  691.         }
  692.         if(!namespaceIdentico){
  693.             //System.out.println("URI");
  694.             throw new MessageException("Node1 ["+el1.getNodeName()+"] possiede un namespace ["+str1+"] differente dal namespace del Node2 ["+el2.getNodeName()+"] (namespace:"+str2+")");
  695.         }
  696.         
  697.         
  698.         /*****************************Controllo se i namespace sono uguali********************************/
  699.         Iterator<?> nameSp1=el1.getNamespacePrefixes();
  700.         Iterator<?> nameSp2=el2.getNamespacePrefixes();
  701.         List <String>nameSpVet1=new ArrayList<>();
  702.         List <String>nameSpVet2=new ArrayList<>();
  703.         String prefix1, prefix2, urlPrefix1, urlPrefix2;
  704.         while(nameSp1.hasNext() && nameSp2.hasNext())
  705.         {
  706.             prefix1=(String) nameSp1.next();
  707.             try{
  708.                 urlPrefix1 = el1.getNamespaceURI(prefix1);
  709.             }catch(Exception e){
  710.                 urlPrefix1 = el1.getNamespaceURI();
  711.             }
  712.             nameSpVet1.add(prefix1+"="+urlPrefix1);
  713.             
  714.             if(namespacePrefixEl1.contains((prefix1+"="+urlPrefix1))==false){
  715.                 //System.out.println("ADD COMPLESSIVO: "+prefix1+"="+urlPrefix1);
  716.                 namespacePrefixEl1.add(prefix1+"="+urlPrefix1);
  717.             }
  718.             
  719.             prefix2=(String) nameSp2.next();
  720.             try{
  721.                 urlPrefix2 = el2.getNamespaceURI(prefix2);
  722.             }catch(Exception e){
  723.                 urlPrefix2 = el2.getNamespaceURI();
  724.             }
  725.             nameSpVet2.add(prefix2+"="+urlPrefix2);            
  726.         }
  727.         
  728.         // Controllo uguaglianza
  729.         for(int i=0; i<nameSpVet1.size(); i++){
  730.             String n1 = (String) nameSpVet1.get(i);
  731.             boolean trovato = false;
  732.             for(int j=0; j<nameSpVet2.size(); j++){
  733.                 String n2 = (String) nameSpVet2.get(j);
  734.                 if(n1.equals(n2)){
  735.                     trovato = true;
  736.                     break;
  737.                 }           
  738.             }
  739.             if(trovato==false){
  740.                 // Cerco nei namespaces del padre
  741.                 if(namespacePrefixEl1.contains(n1)==false){
  742.                     //System.out.println("NON TROVATO: "+n1);
  743.                     throw new MessageException("Node1 ["+el1.getNodeName()+"] non contiene il prefix: "+n1);
  744.                 }
  745.             }
  746.         }
  747.         

  749.         if(!(nameSpVet1.size() == nameSpVet2.size())){
  750.             //System.out.println("SIZE NAMESPACE");
  751.             
  752.             StringBuilder bfNode1 = new StringBuilder();
  753.             for (int i = 0; i < nameSpVet1.size(); i++) {
  754.                 if(i>0){
  755.                     bfNode1.append(",");
  756.                 }
  757.                 bfNode1.append(nameSpVet1.get(i));
  758.             }
  759.             
  760.             StringBuilder bfNode2 = new StringBuilder();
  761.             for (int i = 0; i < nameSpVet2.size(); i++) {
  762.                 if(i>0){
  763.                     bfNode2.append(",");
  764.                 }
  765.                 bfNode2.append(nameSpVet2.get(i));
  766.             }
  767.             
  768.             throw new MessageException("Node1 ["+el1.getNodeName()+"] e Node2 ["+el2.getNodeName()+"] non hanno gli stessi prefix. Attributi("+nameSpVet1.size()+") di Node1: "+bfNode1+ " . Attributi("+nameSpVet2.size()+") di Node2: "+bfNode2);
  769.         }    
  770.         


  773.         /*****************chiamata ricorsiva per i figli********************/
  774.         Iterator<?> child=el1.getChildElements();
  775.         Iterator<?> child2=el2.getChildElements();
  776.         while(child.hasNext()){
  777.             if(checkTextComment){
  778.                 if(!child2.hasNext()){
  779.                     //System.out.println("CHILD1");
  780.                     throw new MessageException("Node2 ["+el2.getNodeName()+"] non ha child element, mentre il Node1 ["+el1.getNodeName()+"] ne possiede"); 
  781.                 }
  782.             }
  783.             Object obj=null;
  784.             if(child.hasNext())
  785.                 obj = child.next();
  786.             
  787.             Object obj2=null;
  788.             if(child2.hasNext())
  789.                 obj2=child2.next();
  790.             
  791.             if(checkTextComment==false){
  792.                 
  793.                 while( (obj!=null) && (obj instanceof Text) ){
  794.                     if(child.hasNext()){
  795.                         obj=child.next();
  796.                     }
  797.                     else{
  798.                         obj=null;
  799.                     }
  800.                 }
  801.                 
  802.                 while( (obj2!=null) && (obj2 instanceof Text) ){
  803.                     if(child2.hasNext()){
  804.                         obj2=child2.next();
  805.                     }
  806.                     else{
  807.                         obj2=null;
  808.                     }
  809.                 }
  810.             
  811.                 if(obj==null){
  812.                     if(obj2!=null){
  813.                         throw new MessageException("Node2 ["+el2.getNodeName()+"] possiede ulteriori child element ("+((SOAPElement)obj2).getNodeName()+") non presenti nel Node1 ["+el1.getNodeName()+"]");
  814.                     }
  815.                     else{
  816.                         break; // elementi terminati
  817.                     }
  818.                 }
  819.                 else{
  820.                     if(obj2==null){
  821.                         throw new MessageException("Node1 ["+el1.getNodeName()+"] possiede ulteriori child element ("+((SOAPElement)obj).getNodeName()+") non presenti nel Node2 ["+el2.getNodeName()+"]");
  822.                     }
  823.                 }
  824.             }
  825.             
  826.             
  827.             if (obj instanceof Text) {
  828.                 Text text = (Text) obj;
  829.                 if (!(obj2 instanceof Text)){
  830.                     //System.out.println("CHILD2");
  831.                     throw new MessageException("Node2 ["+el2.getNodeName()+"] non possiede l'element Text presente nel Node1 ["+el1.getNodeName()+"] (valore: "+text.toString()+")"); 
  832.                 }
  833.                 else{
  834.                     Text text2 = (Text) obj2;
  835.                     boolean value = text.toString().equals(text2.toString());
  836.                     //System.out.println("CHILD3 ["+value+"]");
  837.                     if(value==false){
  838.                         throw new MessageException("Node2 ["+el2.getNodeName()+"] possiede un element Text con valore ("+text2.toString()+") differente da quello presente nel Node1 ["+el1.getNodeName()+"] (valore:"+text.toString()+")");
  839.                     }
  840.                 }
  841.             }
  842.             else{
  843.                 if(obj2 instanceof Text){
  844.                     //System.out.println("CHILD4");
  845.                     throw new MessageException("Node2 ["+el2.getNodeName()+"] possiede un element Text ("+((Text)obj2).toString()+") non presente nel Node1 ["+el1.getNodeName()+"]"); 
  846.                 }
  847.                 @SuppressWarnings("unchecked")
  848.                 List<String> namespacePrefixEl1Parent = (List<String>) ((ArrayList<String>) namespacePrefixEl1).clone();
  849.                 _equalsSoapElements((SOAPElement)obj, (SOAPElement)obj2 , namespacePrefixEl1Parent,checkTextComment);
  850.             }
  851.         }


  854.     }
  855.     
  856.     
  857.     
  858.     



  862.     /* ********  FAULT  ******** */ 


  865.     public static String toString(OpenSPCoop2MessageFactory messageFactory, SOAPFault fault) throws MessageException{
  866.         return SoapUtils.toString(messageFactory, fault,true);
  867.     }
  868.     
  869.     public static String toString(OpenSPCoop2MessageFactory messageFactory, SOAPFault fault,boolean printDetails) throws MessageException{
  870.         return SoapUtils._toString(messageFactory, fault, true, true, null);
  871.     }
  872.     
  873.     public static String safe_toString(OpenSPCoop2MessageFactory messageFactory, SOAPFault fault, Logger log) throws MessageException{
  874.         return SoapUtils.safe_toString(messageFactory, fault, false, log);
  875.     }
  876.     
  877.     public static String safe_toString(OpenSPCoop2MessageFactory messageFactory, SOAPFault fault,boolean printDetails, Logger log) throws MessageException{
  878.         return SoapUtils._toString(messageFactory, fault, true, false, log);
  879.     }
  880.     
  881.     public static String _toString(OpenSPCoop2MessageFactory messageFactory, SOAPFault fault,boolean printDetails, 
  882.             boolean throwsException, Logger log) throws MessageException{
  883.         try{
  884.             if(printDetails){
  885.                 if(fault!=null){
  886.                     return OpenSPCoop2MessageFactory.getAsString(messageFactory, fault,true);
  887.                 }else{
  888.                     return "SOAPFault non presente";
  889.                 }   
  890.             }
  891.             else{
  892.                 StringBuilder bf = new StringBuilder();
  893.                 if(fault!=null){
  894.                     bf.append("SOAPFault");
  895.                     try{
  896.                         if(fault.getFaultCode()!=null && !"".equals(fault.getFaultCode())){
  897.                             bf.append(" faultCode["+fault.getFaultCode()+"]");
  898.                         }
  899.                     } catch(Throwable e) {
  900.                         if(throwsException) {
  901.                             throw e;
  902.                         }
  903.                         bf.append(" faultCode[unparsable: "+e.getMessage()+"]");
  904.                     }
  905.                     try{
  906.                         if(fault.getFaultActor()!=null && !"".equals(fault.getFaultActor())){
  907.                             bf.append(" faultActor["+fault.getFaultActor()+"]");
  908.                         }
  909.                     } catch(Throwable e) {
  910.                         if(throwsException) {
  911.                             throw e;
  912.                         }
  913.                         bf.append(" faultActor[unparsable: "+e.getMessage()+"]");
  914.                     }
  915.                     try{
  916.                         if(fault.getFaultString()!=null && !"".equals(fault.getFaultString())){
  917.                             bf.append(" faultString["+fault.getFaultString()+"]");
  918.                         }
  919.                     } catch(Throwable e) {
  920.                         if(throwsException) {
  921.                             throw e;
  922.                         }
  923.                         bf.append(" faultString[unparsable: "+e.getMessage()+"]");
  924.                     }
  925.                     
  926.                 }else{
  927.                     return "SOAPFault non presente";
  928.                 }
  929.                 
  930.                 return bf.toString();
  931.             }
  932.             
  933.         } catch(Throwable e) {
  934.             if(throwsException) {
  935.                 throw new MessageException("toString SOAPFault: "+e.getMessage(),e);
  936.             }
  937.             else {
  938.                 if(log!=null) {
  939.                     log.error("Unparsable SOAPFault: "+e.getMessage(),e);
  940.                 }
  941.                 return "Unparsable SOAPFault: "+e.getMessage();
  942.             }
  943.         }
  944.     }


  947.     
  948.     
  949.     
  950.     
  951.     
  952.     
  953.     /* ********  M E S S A G G I    F A U L T     S O A P    ******** */ 
  954.     
  955.     /**
  956.      * Metodo che si occupa di costruire un messaggio <code>SOAPFault</code>  con i seguenti campi :
  957.      * <p>
  958.      * <ul>
  959.      *   <li> FaultString : parametro <var>aFault</var>,
  960.      *   <li> FaultCode   : parametro <var>aCode</var>,
  961.      *   <li> FaultActor  : parametro <var>aActor</var>,
  962.      *   <li> <code>Detail</code> composto da tanti Detail quanto sono la lunghezza dei parametri seguenti :
  963.      *   <ul>
  964.      *       <li> LocalName : parametro <var>aDetailLocalName</var>,
  965.      *       <li> Prefix    : parametro <var>aDetailPrefix</var>,
  966.      *       <li> URI       : parametro <var>aDetailURI</var>,
  967.      *   </ul>
  968.      * </ul>
  969.      *
  970.      * @param aFault faultString del SOAPFault.
  971.      * @param aActor faultActor del SOAPFault.
  972.      * @param aCode  faultCode del SOAPFault.
  973.      * @param dettaglioEccezione Dettaglio dell'eccezione
  974.      * @return <tt>byte[]</tt> del messaggio Soap Fault costruito in caso di successo, <tt>null</tt> altrimenti.
  975.      * 
  976.      */
  977.     public static byte[] build_Soap_Fault(OpenSPCoop2MessageFactory messageFactory, MessageType messageType, String aFault, String aActor, QName aCode, 
  978.             Element dettaglioEccezione,boolean generaDetails) throws MessageException, MessageNotSupportedException  {

  980.         if(!MessageType.SOAP_11.equals(messageType) && !MessageType.SOAP_12.equals(messageType)){
  981.             throw MessageNotSupportedException.newMessageNotSupportedException(messageType);
  982.         }
  983.         
  984.         ByteArrayOutputStream byteMessaggio = null;
  985.         try{
  986.             OpenSPCoop2Message msg = messageFactory.createEmptyMessage(messageType,MessageRole.FAULT);
  987.             OpenSPCoop2SoapMessage soapMsg = msg.castAsSoap();
  988.             SOAPEnvelope env = (soapMsg.getSOAPPart()).getEnvelope();

  990.             //log.info("Setting SOAPBody with SOAPFault");
  991.             SOAPBody bdy = env.getBody();
  992.             bdy.addFault();
  993.             SOAPFault fault = bdy.getFault();

  995.             //log.info("Setting Fault");
  996.             
  997.             if(aFault != null)
  998.                 fault.setFaultString(aFault);
  999.             else
  1000.                 fault.setFaultString("");

  1002.             //log.info("Setting Fault Code");
  1003.             
  1004.             if(aCode != null)
  1005.                 fault.setFaultCode(aCode);

  1007.             //log.info("Setting Actor");
  1008.             if(aActor != null)
  1009.                 fault.setFaultActor(aActor);

  1011.             //log.info("Setting Details");
  1012.             if(generaDetails && dettaglioEccezione!=null){
  1013.                 fault.addDetail();  
  1014.                 Detail d = fault.getDetail();
  1015.                 d.appendChild(d.getOwnerDocument().importNode(dettaglioEccezione,true));
  1016.             }

  1018.             //log.info("Build complete MessageSOAPFault");

  1020.             // Return byte ....
  1021.             byteMessaggio = new ByteArrayOutputStream();
  1022.             msg.writeTo(byteMessaggio, true);
  1023.             //log.info("-----Imbustamento------");
  1024.             //log.info(byteMessaggio.toString());
  1025.             //log.info("-----Imbustamento------");

  1027.             byte [] risultato = byteMessaggio.toByteArray();
  1028.             byteMessaggio.close();
  1029.             return risultato;
  1030.         } catch(Exception e) {
  1031.             try{
  1032.                 if(byteMessaggio!=null)
  1033.                     byteMessaggio.close();
  1034.             }catch(Exception eis){
  1035.                 // close
  1036.             }
  1037.             throw new MessageException("Creazione MsgSOAPFault non riuscito: "+e.getMessage(),e);
  1038.         }
  1039.     }


  1042. }
Created with JaCoCo 0.8.8.202204050719