@SuppressWarnings("unchecked")
    public void process(Exchange exchange) throws Exception {
      CxfPayload<SoapHeader> in = exchange.getIn().getBody(CxfPayload.class);

      // verify request
      assertEquals(1, in.getBody().size());

      Map<String, String> ns = new HashMap<String, String>();
      ns.put("ns", MtomTestHelper.SERVICE_TYPES_NS);
      ns.put("xop", MtomTestHelper.XOP_NS);

      XPathUtils xu = new XPathUtils(ns);
      Element body = new XmlConverter().toDOMElement(in.getBody().get(0));
      Element ele =
          (Element) xu.getValue("//ns:Detail/ns:photo/xop:Include", body, XPathConstants.NODE);
      String photoId = ele.getAttribute("href").substring(4); // skip "cid:"
      assertEquals(MtomTestHelper.REQ_PHOTO_CID, photoId);

      ele = (Element) xu.getValue("//ns:Detail/ns:image/xop:Include", body, XPathConstants.NODE);
      String imageId = ele.getAttribute("href").substring(4); // skip "cid:"
      assertEquals(MtomTestHelper.REQ_IMAGE_CID, imageId);

      DataHandler dr = exchange.getIn().getAttachment(photoId);
      assertEquals("application/octet-stream", dr.getContentType());
      MtomTestHelper.assertEquals(
          MtomTestHelper.REQ_PHOTO_DATA, IOUtils.readBytesFromStream(dr.getInputStream()));

      dr = exchange.getIn().getAttachment(imageId);
      assertEquals("image/jpeg", dr.getContentType());
      MtomTestHelper.assertEquals(
          MtomTestHelper.requestJpeg, IOUtils.readBytesFromStream(dr.getInputStream()));

      // create response
      List<Source> elements = new ArrayList<Source>();
      elements.add(
          new DOMSource(
              DOMUtils.readXml(new StringReader(MtomTestHelper.RESP_MESSAGE))
                  .getDocumentElement()));
      CxfPayload<SoapHeader> sbody =
          new CxfPayload<SoapHeader>(new ArrayList<SoapHeader>(), elements, null);
      exchange.getOut().setBody(sbody);
      exchange
          .getOut()
          .addAttachment(
              MtomTestHelper.RESP_PHOTO_CID,
              new DataHandler(
                  new ByteArrayDataSource(
                      MtomTestHelper.RESP_PHOTO_DATA, "application/octet-stream")));

      exchange
          .getOut()
          .addAttachment(
              MtomTestHelper.RESP_IMAGE_CID,
              new DataHandler(new ByteArrayDataSource(MtomTestHelper.responseJpeg, "image/jpeg")));
    }
  /**
   * Write binary attachment data from a {@link DataHandler}.
   *
   * @see XMLStreamWriterEx#writeBinary(DataHandler)
   */
  public void writeBinary(final DataHandler data) throws XMLStreamException {
    // generate a unique id for the attachment
    final String id = "uuid:" + UUID.randomUUID().toString();
    final DimeRecord dimeRecord = new DimeRecord();
    dimeRecord.setContentId(id);
    dimeRecord.setData(data);
    if (data.getContentType() != null) {
      dimeRecord.setTypeNameFormat(TypeNameFormat.MEDIA_TYPE);
      dimeRecord.setContentType(data.getContentType());
    }
    dimeMessage.add(dimeRecord);

    // write a reference to the SOAP message
    writeAttribute("href", id);
  }
Esempio n. 3
0
  /**
   * Sets the filename associated with this body part.
   *
   * @exception IllegalWriteException if the underlying implementation does not support modification
   * @exception IllegalStateException if this body part is obtained from a READ_ONLY folder
   */
  public void setFileName(String filename) throws MessagingException {
    PrivilegedAction a = new GetSystemPropertyAction("mail.mime.encodefilename");
    if ("true".equals(AccessController.doPrivileged(a))) {
      try {
        filename = MimeUtility.encodeText(filename);
      } catch (UnsupportedEncodingException e) {
        throw new MessagingException(e.getMessage(), e);
      }
    }
    String header = getHeader(CONTENT_DISPOSITION_NAME, null);
    if (header == null) {
      header = "attachment";
    }
    ContentDisposition cd = new ContentDisposition(header);
    cd.setParameter("filename", filename);
    setHeader(CONTENT_DISPOSITION_NAME, cd.toString());

    // We will also set the "name" parameter of the Content-Type field
    // to preserve compatibility with nonconformant MUAs
    header = getHeader(CONTENT_TYPE_NAME, null);
    if (header == null) {
      DataHandler dh0 = getDataHandler();
      if (dh0 != null) header = dh0.getContentType();
      else header = "text/plain";
    }
    try {
      ContentType contentType = new ContentType(header);
      contentType.setParameter("name", filename);
      setHeader(CONTENT_TYPE_NAME, contentType.toString());
    } catch (ParseException e) {
    }
  }
 public void downloadBAMTool(String toolName, HttpServletResponse response)
     throws BAMToolboxDepolyerServiceBAMToolboxDeploymentExceptionException {
   try {
     ServletOutputStream out = response.getOutputStream();
     DataHandler downloadData = stub.downloadToolBox(toolName);
     if (downloadData != null) {
       String fileName = "";
       if (!toolName.endsWith(".tbox")) {
         fileName = toolName + ".tbox";
       } else fileName = toolName;
       response.setHeader("Content-Disposition", "fileName=" + fileName);
       response.setContentType(downloadData.getContentType());
       InputStream in = downloadData.getDataSource().getInputStream();
       int nextChar;
       while ((nextChar = in.read()) != -1) {
         out.write((char) nextChar);
       }
       out.flush();
       in.close();
     } else {
       out.write("The requested service archive was not found on the server".getBytes());
     }
   } catch (RemoteException e) {
     log.error(e.getMessage(), e);
     throw new BAMToolboxDepolyerServiceBAMToolboxDeploymentExceptionException(e);
   } catch (IOException e) {
     log.error(e.getMessage(), e);
     throw new BAMToolboxDepolyerServiceBAMToolboxDeploymentExceptionException(e);
   }
 }
Esempio n. 5
0
 private static String addStudyPOIsAndGetPatientID(
     List<ParticipantObjectIdentification> studyPOIs, RetrieveDocumentSetResponseType rsp) {
   Attributes attrs = null;
   String studyIUID, classUID;
   HashMap<String, HashMap<String, List<String>>> studySopClassMap =
       new HashMap<String, HashMap<String, List<String>>>();
   HashMap<String, List<String>> sopClassInstanceMap;
   List<String> instances;
   for (DocumentResponse doc : rsp.getDocumentResponse()) {
     BufferedInputStream is = null;
     DicomInputStream dis = null;
     try {
       DataHandler dh = doc.getDocument();
       is = new BufferedInputStream(dh.getInputStream(), BUF_SIZE);
       is.mark(BUF_SIZE);
       dis = new DicomInputStream(new BufferedInputStream(is));
       attrs = dis.readDataset(-1, Tag.SeriesInstanceUID);
       is.reset();
       doc.setDocument(new DataHandler(new InputStreamDataSource(is, dh.getContentType())));
       studyIUID = attrs.getString(Tag.StudyInstanceUID);
       classUID = attrs.getString(Tag.SOPClassUID);
       sopClassInstanceMap = studySopClassMap.get(studyIUID);
       if (sopClassInstanceMap == null) {
         sopClassInstanceMap = new HashMap<String, List<String>>();
         studySopClassMap.put(studyIUID, sopClassInstanceMap);
         instances = null;
       } else {
         instances = sopClassInstanceMap.get(classUID);
       }
       if (instances == null) {
         instances = new ArrayList<String>();
         sopClassInstanceMap.put(classUID, instances);
       }
       instances.add(attrs.getString(Tag.SOPInstanceUID));
     } catch (IOException x) {
       log.warn("Failed to read DICOM attachment! instanceUID:" + doc.getDocumentUniqueId(), x);
     }
   }
   for (Entry<String, HashMap<String, List<String>>> e : studySopClassMap.entrySet()) {
     ParticipantObjectDescription pod = new ParticipantObjectDescription();
     studyPOIs.add(createStudyPOI(e.getKey(), pod));
     for (Entry<String, List<String>> e1 : e.getValue().entrySet()) {
       SOPClass sc = new SOPClass();
       sc.setUID(e1.getKey());
       sc.setNumberOfInstances(e1.getValue().size());
       for (String iuid : e1.getValue()) {
         Instance inst = new Instance();
         inst.setUID(iuid);
         sc.getInstance().add(inst);
       }
       pod.getSOPClass().add(sc);
     }
   }
   return attrs == null ? null : attrs.getString(Tag.PatientID);
 }
Esempio n. 6
0
  public DHResponse echoDataHandler(DHRequest request) {
    this.ensureInit();
    DataHandler dataHandler = request.getDataHandler();

    try {
      if (!dataHandler.getContentType().equals("text/plain")) {
        throw new WebServiceException("Wrong content type");
      }
      if (!dataHandler.getContent().equals("some string")) {
        throw new WebServiceException("Wrong data");
      }
    } catch (IOException e) {
      throw new WebServiceException(e);
    }

    DataHandler responseData = new DataHandler("Server data", "text/plain");
    return new DHResponse(responseData);
  }
Esempio n. 7
0
  /**
   * Updates the headers of this part, based on the content.
   *
   * @exception IllegalWriteException if the underlying implementation does not support modification
   * @exception IllegalStateException if this body part is obtained from a READ_ONLY folder
   */
  protected void updateHeaders() throws MessagingException {
    if (getDataHandler() != null) {
      try {
        String contentType = dh.getContentType();
        ContentType ct = new ContentType(contentType);
        if (ct.match("multipart/*")) {
          MimeMultipart mmp = (MimeMultipart) dh.getContent();
          mmp.updateHeaders();
        } else if (ct.match("message/rfc822")) {
        } else {
          // Update Content-Transfer-Encoding
          if (getHeader(CONTENT_TRANSFER_ENCODING_NAME) == null) {
            setHeader(CONTENT_TRANSFER_ENCODING_NAME, MimeUtility.getEncoding(dh));
          }
        }

        // Update Content-Type if nonexistent,
        // and Content-Type "name" with Content-Disposition "filename"
        // parameter(see setFilename())
        if (getHeader(CONTENT_TYPE_NAME) == null) {
          String disposition = getHeader(CONTENT_DISPOSITION_NAME, null);
          if (disposition != null) {
            ContentDisposition cd = new ContentDisposition(disposition);
            String filename = cd.getParameter("filename");
            if (filename != null) {
              ct.setParameter("name", filename);
              contentType = ct.toString();
            }
          }
          setHeader(CONTENT_TYPE_NAME, contentType);
        }
      } catch (IOException e) {
        throw new MessagingException("I/O error", e);
      }
    }
  }
 @Override
 public Object unmarshal(Exchange exchange, InputStream stream)
     throws IOException, MessagingException {
   MimeBodyPart mimeMessage;
   String contentType;
   Message camelMessage;
   Object content = null;
   if (headersInline) {
     mimeMessage = new MimeBodyPart(stream);
     camelMessage = exchange.getOut();
     MessageHelper.copyHeaders(exchange.getIn(), camelMessage, true);
     contentType = mimeMessage.getHeader(CONTENT_TYPE, null);
     // write the MIME headers not generated by javamail as Camel headers
     Enumeration<?> headersEnum = mimeMessage.getNonMatchingHeaders(STANDARD_HEADERS);
     while (headersEnum.hasMoreElements()) {
       Object ho = headersEnum.nextElement();
       if (ho instanceof Header) {
         Header header = (Header) ho;
         camelMessage.setHeader(header.getName(), header.getValue());
       }
     }
   } else {
     // check if this a multipart at all. Otherwise do nothing
     contentType = exchange.getIn().getHeader(CONTENT_TYPE, String.class);
     if (contentType == null) {
       return stream;
     }
     try {
       ContentType ct = new ContentType(contentType);
       if (!ct.match("multipart/*")) {
         return stream;
       }
     } catch (ParseException e) {
       LOG.warn("Invalid Content-Type " + contentType + " ignored");
       return stream;
     }
     camelMessage = exchange.getOut();
     MessageHelper.copyHeaders(exchange.getIn(), camelMessage, true);
     ByteArrayOutputStream bos = new ByteArrayOutputStream();
     IOHelper.copyAndCloseInput(stream, bos);
     InternetHeaders headers = new InternetHeaders();
     extractHeader(CONTENT_TYPE, camelMessage, headers);
     extractHeader(MIME_VERSION, camelMessage, headers);
     mimeMessage = new MimeBodyPart(headers, bos.toByteArray());
     bos.close();
   }
   DataHandler dh;
   try {
     dh = mimeMessage.getDataHandler();
     if (dh != null) {
       content = dh.getContent();
       contentType = dh.getContentType();
     }
   } catch (MessagingException e) {
     LOG.warn("cannot parse message, no unmarshalling done");
   }
   if (content instanceof MimeMultipart) {
     MimeMultipart mp = (MimeMultipart) content;
     content = mp.getBodyPart(0);
     for (int i = 1; i < mp.getCount(); i++) {
       BodyPart bp = mp.getBodyPart(i);
       DefaultAttachment camelAttachment = new DefaultAttachment(bp.getDataHandler());
       @SuppressWarnings("unchecked")
       Enumeration<Header> headers = bp.getAllHeaders();
       while (headers.hasMoreElements()) {
         Header header = headers.nextElement();
         camelAttachment.addHeader(header.getName(), header.getValue());
       }
       camelMessage.addAttachmentObject(getAttachmentKey(bp), camelAttachment);
     }
   }
   if (content instanceof BodyPart) {
     BodyPart bp = (BodyPart) content;
     camelMessage.setBody(bp.getInputStream());
     contentType = bp.getContentType();
     if (contentType != null && !DEFAULT_CONTENT_TYPE.equals(contentType)) {
       camelMessage.setHeader(CONTENT_TYPE, contentType);
       ContentType ct = new ContentType(contentType);
       String charset = ct.getParameter("charset");
       if (charset != null) {
         camelMessage.setHeader(Exchange.CONTENT_ENCODING, MimeUtility.javaCharset(charset));
       }
     }
   } else {
     // If we find no body part, try to leave the message alone
     LOG.info("no MIME part found");
   }
   return camelMessage;
 }
Esempio n. 9
0
 /**
  * Set the Content and the MimeType from the DatHandler. This method defers to the
  * setContent(InputStream) method by passing it the InputStream retrieved from the DataHandler.
  * That means it currently blocks while reading, consuming, and encoding the InputStream. TODO:
  * The better approach would be to simple store the DataHandler in the exts table directly and
  * use a custom TypeAdapter for the BinaryObject to read and consume the DataHandler during the
  * actual Serialization.
  */
 public M data(DataHandler data, Hasher hash, CompressionCodec... comps) throws IOException {
   data(data.getInputStream(), hash, comps);
   if (!a) mimeType(data.getContentType());
   return (M) this;
 }