javax.xml.soap.AttachmentPart Java Examples

public <T> T asObject(Class<T> clazz) throws SOAPException {
   if (!clazz.isAnnotationPresent(XmlRootElement.class)) {
      throw new IllegalArgumentException("Class [" + clazz + "] is not annotated with @XMLRootElement");
   } else {
      this.getSOAPException();
      MarshallerHelper<T, T> helper = new MarshallerHelper(clazz, clazz);
      helper.clearAttachmentPartMap();
      Iterator attachmentPartIterator = this.message.getAttachments();

      while(attachmentPartIterator.hasNext()) {
         AttachmentPart element = (AttachmentPart)attachmentPartIterator.next();
         helper.addAttachmentPart(this.getAttachmentPartId(element), element);
      }

    T res = helper.toObject((Node) this.getFirstChildElement());

      if (res instanceof SoapConversationLogger) {
       ((SoapConversationLogger) res).setSoapRequest(this.request);
       ((SoapConversationLogger) res).setSoapResponse(this.message);
      }

    return res;
   }
}
 

public void parseAll() throws MessagingException {
    if (parsed) {
        return;
    }
    if (soapPart == null) {
        readSOAPPart();
    }

    List<MIMEPart> prts = mm.getAttachments();
    for(MIMEPart part : prts) {
        if (part != soapPart) {
            AttachmentPart attach = new AttachmentPartImpl(part);
            this.addBodyPart(new MimeBodyPart(part));
        }
   }
   parsed = true;
}
 

public void parseAll() throws MessagingException {
    if (parsed) {
        return;
    }
    if (soapPart == null) {
        readSOAPPart();
    }

    List<MIMEPart> prts = mm.getAttachments();
    for(MIMEPart part : prts) {
        if (part != soapPart) {
            AttachmentPart attach = new AttachmentPartImpl(part);
            this.addBodyPart(new MimeBodyPart(part));
        }
   }
   parsed = true;
}
 

private static void assertAttachmentsAreEqual(SOAPMessage expected, SOAPMessage actual)
    throws Exception {
  int expectedNumAttachments = expected.countAttachments();
  int actualNumAttachments = actual.countAttachments();
  if (expectedNumAttachments != actualNumAttachments) {
    throw new Exception(
        "expectedNumAttachments="
            + expectedNumAttachments
            + "actualNumAttachments="
            + actualNumAttachments);
  }
  Iterator<?> expectedAttachmentIterator = expected.getAttachments();
  Iterator<?> actualAttachmentIterator = actual.getAttachments();
  for (int attachmentIndex = 0; attachmentIndex < actualNumAttachments; attachmentIndex++) {
    AttachmentPart expectedAttachment = (AttachmentPart) expectedAttachmentIterator.next();
    AttachmentPart actualAttachment = (AttachmentPart) actualAttachmentIterator.next();
    assertEquals(expectedAttachment, actualAttachment, attachmentIndex);
  }
}
 

public <T> T asObject(Class<T> clazz) throws SOAPException {
   if (!clazz.isAnnotationPresent(XmlRootElement.class)) {
      throw new IllegalArgumentException("Class [" + clazz + "] is not annotated with @XMLRootElement");
   } else {
      this.getSOAPException();
      MarshallerHelper<T, T> helper = new MarshallerHelper(clazz, clazz);
      helper.clearAttachmentPartMap();
      Iterator attachmentPartIterator = this.message.getAttachments();

      while(attachmentPartIterator.hasNext()) {
         AttachmentPart element = (AttachmentPart)attachmentPartIterator.next();
         helper.addAttachmentPart(this.getAttachmentPartId(element), element);
      }

      return helper.toObject((Node)this.getFirstChildElement());
   }
}
 

public void parseAll() throws MessagingException {
    if (parsed) {
        return;
    }
    if (soapPart == null) {
        readSOAPPart();
    }

    List<MIMEPart> prts = mm.getAttachments();
    for(MIMEPart part : prts) {
        if (part != soapPart) {
            AttachmentPart attach = new AttachmentPartImpl(part);
            this.addBodyPart(new MimeBodyPart(part));
        }
   }
   parsed = true;
}
 

private SOAPMessage createMessage(MessageFactory mf) throws SOAPException, IOException {
    SOAPMessage msg = mf.createMessage();
    SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();
    Name name = envelope.createName("hello", "ex", "http://example.com");
    envelope.getBody().addChildElement(name).addTextNode("THERE!");

    String s = "<root><hello>THERE!</hello></root>";

    AttachmentPart ap = msg.createAttachmentPart(
            new StreamSource(new ByteArrayInputStream(s.getBytes())),
            "text/xml"
    );
    msg.addAttachmentPart(ap);
    msg.saveChanges();

    return msg;
}
 

protected SOAPMessageContext createSOAPMessageCtx(GenericRequest genericRequest) throws TechnicalConnectorException {
   try {
      SOAPMessage soapMessage = mf.createMessage();
      SOAPPart soapPart = soapMessage.getSOAPPart();
      if (genericRequest.isXopEnabled()) {
         soapMessage.getMimeHeaders().addHeader("Content-Type", "application/xop+xml");
         soapPart.addMimeHeader("Content-ID", "<[email protected]>");
         soapPart.addMimeHeader("Content-Transfer-Encoding", "8bit");
      }

      SOAPEnvelope soapEnvelope = soapPart.getEnvelope();
      SOAPBody soapBody = soapEnvelope.getBody();
      soapBody.addDocument(genericRequest.getPayload());
      Map<String, DataHandler> handlers = genericRequest.getDataHandlerMap();

      AttachmentPart part;
      for(Iterator i$ = handlers.entrySet().iterator(); i$.hasNext(); soapMessage.addAttachmentPart(part)) {
         Entry<String, DataHandler> handlerEntry = (Entry)i$.next();
         DataHandler handler = (DataHandler)handlerEntry.getValue();
         part = soapMessage.createAttachmentPart(handler);
         part.setContentType(handler.getContentType());
         if (genericRequest.isXopEnabled()) {
            part.addMimeHeader("Content-Transfer-Encoding", "binary");
            part.setContentId("<" + (String)handlerEntry.getKey() + ">");
         } else {
            part.setContentId((String)handlerEntry.getKey());
         }
      }

      return createSOAPMessageCtx(soapMessage);
   } catch (SOAPException var11) {
      throw translate(var11);
   }
}
 

public <T> T asObject(Class<T> clazz) throws SOAPException {
   if (!clazz.isAnnotationPresent(XmlRootElement.class)) {
      throw new IllegalArgumentException("Class [" + clazz + "] is not annotated with @XMLRootElement");
   } else {
      this.getSOAPException();
      MarshallerHelper<T, T> helper = new MarshallerHelper(clazz, clazz);
      helper.clearAttachmentPartMap();
      Iterator attachmentPartIterator = this.message.getAttachments();

      while(attachmentPartIterator.hasNext()) {
         AttachmentPart element = (AttachmentPart)attachmentPartIterator.next();
         helper.addAttachmentPart(this.getAttachmentPartId(element), element);
      }

      return helper.toObject((Node)this.getFirstChildElement());
   }
}
 

public void parseAll() throws MessagingException {
    if (parsed) {
        return;
    }
    if (soapPart == null) {
        readSOAPPart();
    }

    List<MIMEPart> prts = mm.getAttachments();
    for(MIMEPart part : prts) {
        if (part != soapPart) {
            AttachmentPart attach = new AttachmentPartImpl(part);
            this.addBodyPart(new MimeBodyPart(part));
        }
   }
   parsed = true;
}
 

public <T> T asObject(Class<T> clazz) throws SOAPException {
   if (!clazz.isAnnotationPresent(XmlRootElement.class)) {
      throw new IllegalArgumentException("Class [" + clazz + "] is not annotated with @XMLRootElement");
   } else {
      this.getSOAPException();
      MarshallerHelper<T, T> helper = new MarshallerHelper(clazz, clazz);
      helper.clearAttachmentPartMap();
      Iterator attachmentPartIterator = this.message.getAttachments();

      while(attachmentPartIterator.hasNext()) {
         AttachmentPart element = (AttachmentPart)attachmentPartIterator.next();
         helper.addAttachmentPart(this.getAttachmentPartId(element), element);
      }

      return helper.toObject((Node)this.getFirstChildElement());
   }
}
 

public void parseAll() throws MessagingException {
    if (parsed) {
        return;
    }
    if (soapPart == null) {
        readSOAPPart();
    }

    List<MIMEPart> prts = mm.getAttachments();
    for(MIMEPart part : prts) {
        if (part != soapPart) {
            AttachmentPart attach = new AttachmentPartImpl(part);
            this.addBodyPart(new MimeBodyPart(part));
        }
   }
   parsed = true;
}
 

public <T> T asObject(Class<T> clazz) throws SOAPException {
   if (!clazz.isAnnotationPresent(XmlRootElement.class)) {
      throw new IllegalArgumentException("Class [" + clazz + "] is not annotated with @XMLRootElement");
   } else {
      this.getSOAPException();
      MarshallerHelper<T, T> helper = new MarshallerHelper(clazz, clazz);
      helper.clearAttachmentPartMap();
      Iterator attachmentPartIterator = this.message.getAttachments();

      while(attachmentPartIterator.hasNext()) {
         AttachmentPart element = (AttachmentPart)attachmentPartIterator.next();
         helper.addAttachmentPart(this.getAttachmentPartId(element), element);
      }

      return helper.toObject((Node)this.getFirstChildElement());
   }
}
 

@Override
public void writeTo(SOAPMessage saaj) throws SOAPException {
    AttachmentPart part = saaj.createAttachmentPart();
    part.setDataHandler(asDataHandler());
    part.setContentId(contentId);
    saaj.addAttachmentPart(part);
}
 

void addSoapAttachement() {
    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage message = messageFactory.createMessage();
        AttachmentPart a = message.createAttachmentPart();
        a.setContentType("binary/octet-stream");
        message.addAttachmentPart(a);
    } catch (SOAPException e) {
        e.printStackTrace();
    }
}
 

void addSoapAttachement() {
    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage message = messageFactory.createMessage();
        AttachmentPart a = message.createAttachmentPart();
        a.setContentType("binary/octet-stream");
        message.addAttachmentPart(a);
    } catch (SOAPException e) {
        e.printStackTrace();
    }
}
 

private SOAPMessage createMessage(InputStream stream, boolean addAttachment) throws IOException, SOAPException {
	MessageFactory factory = MessageFactory.newInstance();
	SOAPMessage soapMessage = factory.createMessage();
	StreamSource streamSource = new StreamSource(stream);
	soapMessage.getSOAPPart().setContent(streamSource);

	if(addAttachment) {
		InputStream fis = new ByteArrayInputStream(ATTACHMENT_CONTENT.getBytes());
		DataHandler dataHander = new DataHandler(new ByteArrayDataSource(fis, ATTACHMENT_MIMETYPE));

		AttachmentPart part = soapMessage.createAttachmentPart(dataHander);
		soapMessage.addAttachmentPart(part);
	}
	return soapMessage;
}
 

void addSoapAttachement() {
    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage message = messageFactory.createMessage();
        AttachmentPart a = message.createAttachmentPart();
        a.setContentType("binary/octet-stream");
        message.addAttachmentPart(a);
    } catch (SOAPException e) {
        e.printStackTrace();
    }
}
 

static protected void addAttachmentsToSOAPMessage(SOAPMessage msg, Message message) {
    for(Attachment att : message.getAttachments()) {
        AttachmentPart part = msg.createAttachmentPart();
        part.setDataHandler(att.asDataHandler());

        // Be safe and avoid double angle-brackets.
        String cid = att.getContentId();
        if (cid != null) {
            if (cid.startsWith("<") && cid.endsWith(">"))
                part.setContentId(cid);
            else
                part.setContentId('<' + cid + '>');
        }

        // Add any MIME headers beside Content-ID, which is already
        // accounted for above, and Content-Type, which is provided
        // by the DataHandler above.
        if (att instanceof AttachmentEx) {
            AttachmentEx ax = (AttachmentEx) att;
            Iterator<AttachmentEx.MimeHeader> imh = ax.getMimeHeaders();
            while (imh.hasNext()) {
                AttachmentEx.MimeHeader ame = imh.next();
                if ((!"Content-ID".equals(ame.getName()))
                        && (!"Content-Type".equals(ame.getName())))
                    part.addMimeHeader(ame.getName(), ame.getValue());
            }
        }
        msg.addAttachmentPart(part);
    }
}
 

void addSoapAttachement() {
    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage message = messageFactory.createMessage();
        AttachmentPart a = message.createAttachmentPart();
        a.setContentType("binary/octet-stream");
        message.addAttachmentPart(a);
    } catch (SOAPException e) {
        e.printStackTrace();
    }
}
 

void addSoapAttachement() {
    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage message = messageFactory.createMessage();
        AttachmentPart a = message.createAttachmentPart();
        a.setContentType("binary/octet-stream");
        message.addAttachmentPart(a);
    } catch (SOAPException e) {
        e.printStackTrace();
    }
}
 

void addSoapAttachement() {
    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage message = messageFactory.createMessage();
        AttachmentPart a = message.createAttachmentPart();
        a.setContentType("binary/octet-stream");
        message.addAttachmentPart(a);
    } catch (SOAPException e) {
        e.printStackTrace();
    }
}
 

@Override
public void writeTo(SOAPMessage saaj) throws SOAPException {
    AttachmentPart part = saaj.createAttachmentPart();
    part.setDataHandler(asDataHandler());
    part.setContentId(contentId);
    saaj.addAttachmentPart(part);
}
 

static protected void addAttachmentsToSOAPMessage(SOAPMessage msg, Message message) {
    for(Attachment att : message.getAttachments()) {
        AttachmentPart part = msg.createAttachmentPart();
        part.setDataHandler(att.asDataHandler());

        // Be safe and avoid double angle-brackets.
        String cid = att.getContentId();
        if (cid != null) {
            if (cid.startsWith("<") && cid.endsWith(">"))
                part.setContentId(cid);
            else
                part.setContentId('<' + cid + '>');
        }

        // Add any MIME headers beside Content-ID, which is already
        // accounted for above, and Content-Type, which is provided
        // by the DataHandler above.
        if (att instanceof AttachmentEx) {
            AttachmentEx ax = (AttachmentEx) att;
            Iterator<AttachmentEx.MimeHeader> imh = ax.getMimeHeaders();
            while (imh.hasNext()) {
                AttachmentEx.MimeHeader ame = imh.next();
                if ((!"Content-ID".equals(ame.getName()))
                        && (!"Content-Type".equals(ame.getName())))
                    part.addMimeHeader(ame.getName(), ame.getValue());
            }
        }
        msg.addAttachmentPart(part);
    }
}
 

@Override
public void writeTo(SOAPMessage saaj) throws SOAPException {
    AttachmentPart part = saaj.createAttachmentPart();
    part.setDataHandler(asDataHandler());
    part.setContentId(contentId);
    saaj.addAttachmentPart(part);
}
 

void addSoapAttachement() {
    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage message = messageFactory.createMessage();
        AttachmentPart a = message.createAttachmentPart();
        a.setContentType("binary/octet-stream");
        message.addAttachmentPart(a);
    } catch (SOAPException e) {
        e.printStackTrace();
    }
}
 

public DataHandler getAttachmentAsDataHandler(String cid) {
   AttachmentPart attachment = (AttachmentPart)this.attachments.get(decode(cid));

   try {
      return attachment.getDataHandler();
   } catch (SOAPException var4) {
      throw new IllegalStateException(var4);
   }
}
 

@Override
protected String deserializeResponseData(Node responseNode, SOAPMessage message) throws SOAPException {
    // Remove namespace if it's required
    handleNamespace(responseNode);

    // If message has attachments, return the first attachment
    if (message.countAttachments() > 0) {
        logger.debug("SOAP attachment detected. Use attachment as response data.");
        return SOAPHelper.toString((AttachmentPart) message.getAttachments().next());
    }
    // Convert response to string
    return SOAPHelper.toString(responseNode);
}
 

static protected void addAttachmentsToSOAPMessage(SOAPMessage msg, Message message) {
    for(Attachment att : message.getAttachments()) {
        AttachmentPart part = msg.createAttachmentPart();
        part.setDataHandler(att.asDataHandler());

        // Be safe and avoid double angle-brackets.
        String cid = att.getContentId();
        if (cid != null) {
            if (cid.startsWith("<") && cid.endsWith(">"))
                part.setContentId(cid);
            else
                part.setContentId('<' + cid + '>');
        }

        // Add any MIME headers beside Content-ID, which is already
        // accounted for above, and Content-Type, which is provided
        // by the DataHandler above.
        if (att instanceof AttachmentEx) {
            AttachmentEx ax = (AttachmentEx) att;
            Iterator<AttachmentEx.MimeHeader> imh = ax.getMimeHeaders();
            while (imh.hasNext()) {
                AttachmentEx.MimeHeader ame = imh.next();
                if ((!"Content-ID".equals(ame.getName()))
                        && (!"Content-Type".equals(ame.getName())))
                    part.addMimeHeader(ame.getName(), ame.getValue());
            }
        }
        msg.addAttachmentPart(part);
    }
}
 

@Override
public void writeTo(SOAPMessage saaj) throws SOAPException {
    AttachmentPart part = saaj.createAttachmentPart();
    part.setDataHandler(asDataHandler());
    part.setContentId(contentId);
    saaj.addAttachmentPart(part);
}