Example usage for javax.activation DataHandler DataHandler

List of usage examples for javax.activation DataHandler DataHandler

  1. HOME
  2. Java
  3. javax
  4. javax.activation.*
  5. DataHandler
  6. DataHandler

Introduction

In this page you can find the example usage for javax.activation DataHandler DataHandler.

Prototype

public DataHandler(URL url)

Source Link

Document

Create a DataHandler instance referencing a URL.

Usage

From source file:org.wso2.carbon.springservices.ui.SpringServiceMaker.java

public void createAndUploadSpringBean(String serviceHierarchy, String springContextId,
        ServiceUploaderClient client, String springBeanId, String[] beanClasses) throws Exception {
    String filePathFromArchiveId = getFilePathFromArchiveId(springBeanId);
    String filePathForSpringContext = getFilePathFromArchiveId(springContextId);

    Map fileResMap = (Map) configContext.getProperty(FILE_RESOURCE_MAP);
    fileResMap.remove(springContextId);//w  w  w .ja va2  s. c o  m

    if (filePathFromArchiveId == null) {
        String msg = bundle.getString("spring.non.existent.file");
        log.warn(msg);
        throw new AxisFault(msg);
    }

    int endIndex = filePathFromArchiveId.lastIndexOf(File.separator);
    String filePath = filePathFromArchiveId.substring(0, endIndex);
    String archiveFileName = filePathFromArchiveId.substring(endIndex);
    archiveFileName = archiveFileName.substring(1, archiveFileName.lastIndexOf("."));

    ArchiveManipulator archiveManipulator = new ArchiveManipulator();

    // ----------------- Unzip the file ------------------------------------
    String unzippeDir = filePath + File.separator + "springTemp";
    File unzipped = new File(unzippeDir);
    if (!unzipped.mkdirs()) {
        log.error("Error while creating directories..");
    }

    try {
        archiveManipulator.extract(filePathFromArchiveId, unzippeDir);
    } catch (IOException e) {
        String msg = bundle.getString("spring.cannot.extract.archive");
        handleException(msg, e);
    }

    // TODO copy the spring xml
    String springContextRelLocation = "spring/context.xml";
    FileInputStream in = null;
    FileOutputStream out = null;

    try {
        File springContextRelDir = new File(unzippeDir + File.separator + "spring");
        if (!springContextRelDir.mkdirs()) {
            log.error("Error while creating directories..");
        }
        File absFile = new File(springContextRelDir, "context.xml");
        if (!absFile.exists() && !absFile.createNewFile()) {
            log.error("Error while creating file..");
        }
        File file = new File(filePathForSpringContext);
        in = new FileInputStream(file);
        out = new FileOutputStream(absFile);
        // Transfer bytes from in to out
        byte[] buf = new byte[1024];
        int len;
        while ((len = in.read(buf)) > 0) {
            out.write(buf, 0, len);
        }

    } catch (FileNotFoundException e) {
        throw AxisFault.makeFault(e);
    } catch (IOException e) {
        throw AxisFault.makeFault(e);
    } finally {
        try {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.flush();
                out.close();
            }
        } catch (IOException e) {
            throw AxisFault.makeFault(e);
        }
    }

    // ---- Generate the services.xml and place it in META-INF -----
    File file = new File(unzippeDir + File.separator + "META-INF" + File.separator + "services.xml");
    if (!file.mkdirs()) {
        log.error("Error while creating directories..");
    }

    try {
        File absoluteFile = file.getAbsoluteFile();

        if (absoluteFile.exists() && !absoluteFile.delete()) {
            log.error("Error while deleting file..");
        }

        if (!absoluteFile.createNewFile()) {
            log.error("Error while creating file..");
        }

        OutputStream os = new FileOutputStream(file);
        OMElement servicesXML = createServicesXMLFromSpringBeans(beanClasses, springContextRelLocation);
        servicesXML.build();
        servicesXML.serialize(os);
    } catch (Exception e) {
        String msg = bundle.getString("spring.cannot.write.services.xml");
        handleException(msg, e);
    }

    // ----------------- Create the AAR ------------------------------------
    // These are the files to include in the ZIP file
    String outAARFilename = filePath + File.separator + archiveFileName + ".aar";

    try {
        archiveManipulator.archiveDir(outAARFilename, unzipped.getPath());
    } catch (IOException e) {
        String msg = bundle.getString("springcannot.create.new.aar.archive");
        handleException(msg, e);
    }

    File fileToUpload = new File(outAARFilename);

    FileDataSource fileDataSource = new FileDataSource(fileToUpload);
    DataHandler dataHandler = new DataHandler(fileDataSource);

    try {
        client.uploadService(archiveFileName + ".aar", serviceHierarchy, dataHandler);
    } catch (Exception e) {
        String msg = bundle.getString("spring.unable.to.upload");
        handleException(msg, e);
    }

}

From source file:eagle.common.email.EagleMailClient.java

public boolean send(String from, String to, String cc, String title, String templatePath,
        VelocityContext context, Map<String, File> attachments) {
    if (attachments == null || attachments.isEmpty()) {
        return send(from, to, cc, title, templatePath, context);
    }/*ww  w  .j  a v a 2 s.  c o  m*/
    Template t = null;

    List<MimeBodyPart> mimeBodyParts = new ArrayList<MimeBodyPart>();
    Map<String, String> cid = new HashMap<String, String>();

    for (Map.Entry<String, File> entry : attachments.entrySet()) {
        final String attachment = entry.getKey();
        final File attachmentFile = entry.getValue();
        final MimeBodyPart mimeBodyPart = new MimeBodyPart();
        if (attachmentFile != null && attachmentFile.exists()) {
            DataSource source = new FileDataSource(attachmentFile);
            try {
                mimeBodyPart.setDataHandler(new DataHandler(source));
                mimeBodyPart.setFileName(attachment);
                mimeBodyPart.setDisposition(MimeBodyPart.ATTACHMENT);
                mimeBodyPart.setContentID(attachment);
                cid.put(attachment, mimeBodyPart.getContentID());
                mimeBodyParts.add(mimeBodyPart);
            } catch (MessagingException e) {
                LOG.error("Generate mail failed, got exception while attaching files: " + e.getMessage(), e);
            }
        } else {
            LOG.error("Attachment: " + attachment + " is null or not exists");
        }
    }
    //TODO remove cid, because not used at all
    if (LOG.isDebugEnabled())
        LOG.debug("Cid maps: " + cid);
    context.put("cid", cid);

    try {
        t = velocityEngine.getTemplate(BASE_PATH + templatePath);
    } catch (ResourceNotFoundException ex) {
        //         LOGGER.error("Template not found:"+BASE_PATH + templatePath, ex);
    }

    if (t == null) {
        try {
            t = velocityEngine.getTemplate(templatePath);
        } catch (ResourceNotFoundException e) {
            try {
                t = velocityEngine.getTemplate("/" + templatePath);
            } catch (Exception ex) {
                LOG.error("Template not found:" + "/" + templatePath, ex);
            }
        }
    }

    final StringWriter writer = new StringWriter();
    t.merge(context, writer);
    if (LOG.isDebugEnabled())
        LOG.debug(writer.toString());
    return this._send(from, to, cc, title, writer.toString(), mimeBodyParts);
}

From source file:io.mapzone.arena.share.app.EMailSharelet.java

private void sendEmail(final String toText, final String subjectText, final String messageText,
        final boolean withAttachment, final ImagePngContent image) throws Exception {
    MimeMessage msg = new MimeMessage(mailSession());

    msg.addRecipients(RecipientType.TO, InternetAddress.parse(toText, false));
    // TODO we need the FROM from the current user
    msg.addFrom(InternetAddress.parse("support@mapzone.io")); //ArenaConfigMBean.SMTP_USER ) );
    msg.setReplyTo(InternetAddress.parse("DO_NOT_REPLY_TO_THIS_EMAIL@mapzone.io")); //ArenaConfigMBean.SMTP_USER ) );

    msg.setSubject(subjectText, "utf-8");
    if (withAttachment) {
        // add mime multiparts
        Multipart multipart = new MimeMultipart();

        BodyPart part = new MimeBodyPart();
        part.setText(messageText);//ww  w .ja va2s.  c om
        multipart.addBodyPart(part);

        // Second part is attachment
        part = new MimeBodyPart();
        part.setDataHandler(new DataHandler(new URLDataSource(new URL(image.imgResource))));
        part.setFileName("preview.png");
        part.setHeader("Content-ID", "preview");
        multipart.addBodyPart(part);

        // // third part in HTML with embedded image
        // part = new MimeBodyPart();
        // part.setContent( "<img src='cid:preview'>", "text/html" );
        // multipart.addBodyPart( part );

        msg.setContent(multipart);
    } else {
        msg.setText(messageText, "utf-8");
    }
    msg.setSentDate(new Date());
    Transport.send(msg);
}

From source file:es.pode.planificador.negocio.trabajos.CargaODEs.java

/**
 * Mtodo de ejecucin de la tarea./*from  ww  w  .j a va 2s  . c  om*/
 * Publicacin de los ODEs en la plataforma de manera automtica.
 */
public void execute(JobExecutionContext context) throws JobExecutionException {
    Long idTarea = null;
    String usuario = (String) context.getJobDetail().getJobDataMap().get(CtesPlanificador.USUARIO);
    boolean ejecucionIncorrecta = false;

    /* Aadimos la seguridad al proceso */
    log("Usuario que lanza la tarea: " + usuario);
    boolean contextoCargado = Autenticar.cargarContextoSeguridad(usuario);

    if (!contextoCargado) {
        log.error("ERROR: No han cargado los datos en el contexto de seguridad");
        return;
    }

    /*
     *   Parmetros propios del trabajo:
     *       pathODEs, pathODEsCargados, pathODEsNoCargados
     *       msgPublicado, msgNoPublicado y msgDescTrabajo
     *       
    */
    ArrayList parametros = (ArrayList) context.getJobDetail().getJobDataMap().get(CtesPlanificador.PARAMETROS);
    String pathODEs = (String) parametros.get(0);
    String pathODEsCargados = (String) parametros.get(1);
    String pathODEsNoCargados = (String) parametros.get(2);
    String msgPublicado = (String) parametros.get(3);
    String msgNoPublicado = (String) parametros.get(4);
    String msgDescTrabajo = (String) parametros.get(5);
    String sobrescribir = (String) parametros.get(6);

    log("CargaODEs: " + context.getJobDetail().getFullName() + " ejecutandose a las " + new Date());

    /* Comprobamos si existen los directorios de trabajo de la carga de ODEs */
    File fPathODEs = new File(pathODEs);
    if (!fPathODEs.exists()) {
        log.error("Error: El directorio donde se deben encontrar los ODEs no existe o no se puede acceder a l "
                + fPathODEs.getAbsolutePath());
        JobExecutionException excepcion = new JobExecutionException(
                "Error: No se ha podido registrar. El directorio de los ODEs no existe: "
                        + fPathODEs.getAbsolutePath());
        throw excepcion;
    }

    File fpathODEsCargados = new File(pathODEsCargados);
    if (!fpathODEsCargados.exists()) {
        log.error(
                "Error: El directorio donde se deben mover los ODEs cargados no existe o no se puede acceder a l "
                        + fPathODEs.getAbsolutePath());
        JobExecutionException excepcion = new JobExecutionException(
                "Error: No se ha podido registrar. No exste el directorio donde se deben moven los ODEs publicados: "
                        + fpathODEsCargados.getAbsolutePath());
        throw excepcion;
    }

    File fpathODEsNoCargados = new File(pathODEsNoCargados);
    if (!fpathODEsNoCargados.exists()) {
        log.error(
                "Error: El directorio donde se deben mover los ODEs no cargados no existe o no se puede acceder a l "
                        + fpathODEsNoCargados.getAbsolutePath());
        JobExecutionException excepcion = new JobExecutionException(
                "Error: El directorio donde se deben mover los ODEs no cargados no existe o no se puede acceder a l "
                        + fpathODEsNoCargados.getAbsolutePath());
        throw excepcion;
    }

    /* Registramos el inicio del trabajo */
    idTarea = Planificador.registrarInicioTarea(context.getJobDetail().getName(),
            context.getJobDetail().getGroup(), msgDescTrabajo, usuario);

    log("Identificador de la tarea: " + idTarea);

    /* Recorremos el directorio donde estan los ficheros(ODEs) a publicar */

    /* Antiguamente:: Se recogian los odes de una direccion en concreto
       File ODEs = new File(pathODEs);
       File[] arrayList = ODEs.listFiles();
     */

    File fileOde = null;

    String[] odes = UtilesFicheros.obtenerOdesDePath(pathODEs, true, true);

    //recorremos todos los odes
    for (int i = 0; i < odes.length; i++) {
        try {
            log("Carga del ODE: " + odes[i]);

            /* Se comprueba si la tarea ha sido interrumpida */
            if (interrupcion) {
                log("Se para la tarea por peticin del cliente");
                break;
            }

            /* Antes se ignoraba los directorios, ahora obtenermos una lista de los path de los odes
             * que esten dentro de una carpeta o de subcarpetas. no hace falta ignorar los directorios
             * Los directorios no se cargan en el nodo 
                    
            if (arrayList[i].isDirectory()) {
               log("Directorio: " + arrayList[i].getAbsolutePath());
               continue;
            }
                    
            //Nos aseguramos que siga existiendo el fichero a cargar
            if (!arrayList[i].exists()) {
               log("El fichero " + arrayList[i].getAbsolutePath() + " ha sido borrado o movido");
               continue;
            }
                    
            */

            //recogemos el ode correspondiente en un FILE para tratarlo
            fileOde = new File(odes[i]);

            //comprobamos que el ode existe todavia
            if (!fileOde.exists()) {
                log("El fichero " + odes[i] + " ha sido borrado o movido");
                continue;
            }

            FileDataSource fileDS = new FileDataSource(odes[i]);
            log("FileDataSource: " + fileDS.toString());

            /* Llamada al servicio de publicacin con el ODE */
            DataHandler pif = new DataHandler(fileDS);
            log("DataHandler: " + pif.toString());

            String codPublicacion = ServiceLocator.instance().getSrvPlanificadorService().publicarPIF(pif,
                    usuario.toString(), msgDescTrabajo + " " + fileOde.getName(), sobrescribir,
                    fileOde.getName());

            //Tratamos el codigo para que solo contenga el primero si tuviera mas de uno
            String codigoCapado = null;

            if (codPublicacion == null || codPublicacion.equals(""))
                codigoCapado = "20.1";
            else {
                int posicion = codPublicacion.indexOf(";");
                if (posicion == -1)
                    codigoCapado = codPublicacion;
                else
                    codigoCapado = codPublicacion.substring(0, posicion);
            }

            log("PublicarPIF: " + codigoCapado);

            /* Preparacin del registro del resultado de la publicacin */
            TareaEjecutadaVO tarea = new TareaEjecutadaVO();
            tarea.setId(idTarea);
            RegistroTareaEjecutadaVO registro = new RegistroTareaEjecutadaVO();
            registro.setTarea_ejecutada(tarea);
            registro.setFecha(new GregorianCalendar());
            registro.setCodigo(codigoCapado);

            /* Publicacin correcta */
            if (codigoCapado.equals(PUBLICACION_CORRECTA)) {
                log.debug("Registramos que la publicacin ha sido correcta. ODE: " + fileOde.getName());
                registro.setEstado(ConstantesAgrega.TRABAJO_CORRECTO);
                registro.setDescripcion(msgPublicado + ". " + fileOde.getName());

                /* Se mueve el ODE publicado al directorio correspondiente */
                try {
                    log.debug("Fichero: " + pathODEsCargados + File.separator + fileOde.getName());

                    File ficheroCargado = new File(pathODEsCargados + File.separator + fileOde.getName());

                    if (ficheroCargado.exists()) {
                        log.warn("Ya existe un fichero con ese nombre: " + ficheroCargado.getAbsolutePath()
                                + " en la carpeta de cargados. Se elimina para mover el nuevo fichero");
                        ficheroCargado.delete();
                    }

                    boolean mov = fileOde.renameTo(ficheroCargado);
                    if (!mov)
                        log.error("El fichero no se ha podido mover: " + fileOde.getAbsolutePath());
                } catch (Exception e2) {
                    RegistrarTrabajoException excepcion = new RegistrarTrabajoException(
                            "Error: No se ha podido mover el ODE cargado al directorio de ODEs publicados "
                                    + fileOde.getAbsolutePath(),
                            e2);
                    log.error(excepcion);
                }
            } else { // Publicacin incorrecta. El ODE no pasa la validacin
                log.info("El ODE: " + fileOde.getName() + " no es vlido. Cdigo de error: " + codPublicacion);
                registro.setEstado(ConstantesAgrega.TRABAJO_ERRONEO);
                // vamos a recoger el error de publicacion
                if (codPublicacion.indexOf(";") != -1)
                    msgNoPublicado = codPublicacion.substring(codPublicacion.indexOf(";") + 1);
                registro.setDescripcion(msgNoPublicado + ". " + fileOde.getName());
                registro.setCodigo(codigoCapado);
                ejecucionIncorrecta = true;

                /* Se mueve el ODE no publicado al directorio correspondiente */
                try {
                    log.debug(
                            "Fichero no publicado: " + pathODEsNoCargados + File.separator + fileOde.getName());

                    File ficheroNoCargado = new File(pathODEsNoCargados + File.separator + fileOde.getName());

                    if (ficheroNoCargado.exists()) {
                        log.warn("Ya existe un fichero con ese nombre: " + ficheroNoCargado.getAbsolutePath()
                                + " en la carpeta de no cargados. Se elimina para mover el nuevo fichero");
                        ficheroNoCargado.delete();
                    }

                    boolean mov = fileOde.renameTo(ficheroNoCargado);

                    if (!mov)
                        log.error("El fichero no se ha podido mover: " + fileOde.getAbsolutePath());
                } catch (Exception e2) {
                    RegistrarTrabajoException excepcion = new RegistrarTrabajoException(
                            "Error: No se ha podido mover el ODE no publicado " + fileOde.getAbsolutePath(),
                            e2);
                    log.error(excepcion);
                }
            }

            // Se registra en la tabla derivada como ha ido la carga de ese ODE
            try {
                ServiceLocator.instance().getSrvRegistroPlanificadorService().registrarTrabajoHijo(registro);
            } catch (Exception e1) {
                RegistrarTrabajoException excepcion = new RegistrarTrabajoException(
                        "Error: No se ha podido registrar la tarea derivada " + e1.getMessage(), e1);
                log.error(excepcion);
            }
        } catch (Exception e) { // Deberan ser excepciones enviadas del servicio de publicacin de ODEs

            String path = "";

            if (fileOde != null || fileOde.getAbsolutePath() != null)
                path = fileOde.getAbsolutePath();

            log.error("Error publicando ODE: " + path + " " + e);
            ejecucionIncorrecta = true;

            TareaEjecutadaVO tarea = new TareaEjecutadaVO();
            tarea.setId(idTarea);
            RegistroTareaEjecutadaVO registro = new RegistroTareaEjecutadaVO();
            registro.setTarea_ejecutada(tarea);
            registro.setDescripcion(msgNoPublicado + ". " + fileOde.getName() + " " + e.getMessage());
            registro.setEstado(ConstantesAgrega.TRABAJO_ERRONEO);
            registro.setCodigo(EXCEPCION_NO_CONTROLADA);
            registro.setFecha(new GregorianCalendar());

            /* Registramos la no publicacin del ODE */
            try {
                ServiceLocator.instance().getSrvRegistroPlanificadorService().registrarTrabajoHijo(registro);
            } catch (Exception e1) {
                RegistrarTrabajoException excepcion = new RegistrarTrabajoException(
                        "Error: No se ha podido registrar", e1);
                log.error(excepcion);
            }

            /* Se mueve el ODE no publicado al directorio correspondiente */
            try {
                log("Fichero no publicado: " + pathODEsNoCargados + File.separator + fileOde.getName());
                File ficheroNoCargado = new File(pathODEsNoCargados + File.separator + fileOde.getName());

                if (ficheroNoCargado.exists()) {
                    log.warn("Ya existe un fichero con ese nombre: " + ficheroNoCargado.getAbsolutePath()
                            + " en la carpeta de no cargados. Se elimina para mover el nuevo fichero");
                    ficheroNoCargado.delete();
                }

                boolean mov = fileOde.renameTo(ficheroNoCargado);

                if (!mov)
                    log.error("El fichero no se ha podido mover: " + fileOde.getAbsolutePath());
            } catch (Exception e2) {
                RegistrarTrabajoException excepcion = new RegistrarTrabajoException(
                        "Error: No se ha podido mover el ODE no publicado " + fileOde.getAbsolutePath(), e2);
                log.error(excepcion);
            }
        }
    }

    //TODO: De este registro se deber encargar la tarea ejecutada
    /* Registramos la hora de finalizacin de la tarea y si ha sido correcta/incorrecta la publicacin */
    try {
        TareaEjecutadaVO trabajoEjecutado = new TareaEjecutadaVO();
        trabajoEjecutado.setId(idTarea);
        trabajoEjecutado.setFechaFin(new GregorianCalendar());

        if (interrupcion)
            trabajoEjecutado.setEstado(ConstantesAgrega.TRABAJO_INTERRUMPIDO);
        else if (ejecucionIncorrecta)
            trabajoEjecutado.setEstado(ConstantesAgrega.TRABAJO_ERRONEO);
        else
            trabajoEjecutado.setEstado(ConstantesAgrega.TRABAJO_CORRECTO);

        ServiceLocator.instance().getSrvRegistroPlanificadorService()
                .registrarTrabajoFechaFin(trabajoEjecutado);
    } catch (Exception e1) {
        RegistrarTrabajoException excepcion = new RegistrarTrabajoException(
                "Error: No se ha podido registrar el fin del trabajo", e1);
        log.error(excepcion);
    }
}

From source file:org.apache.axiom.util.stax.XMLStreamReaderUtils.java

/**
 * Get a {@link DataHandler} for the binary data encoded in an element. The method supports
 * base64 encoded character data as well as optimized binary data through the
 * {@link DataHandlerReader} extension./*from www.  ja  v a 2  s  .  co m*/
 * <p>
 * <em>Precondition</em>: the reader is on a {@link XMLStreamConstants#START_ELEMENT}
 * <p>
 * <em>Postcondition</em>: the reader is on the corresponding
 * {@link XMLStreamConstants#END_ELEMENT}
 * 
 * @param reader the stream to read the data from
 * @return the binary data from the element
 */
public static DataHandler getDataHandlerFromElement(XMLStreamReader reader) throws XMLStreamException {

    int event = reader.next();
    if (event == XMLStreamConstants.END_ELEMENT) {
        // This means that the element is actually empty -> return empty DataHandler
        return new DataHandler(new EmptyDataSource("application/octet-stream"));
    } else if (event != XMLStreamConstants.CHARACTERS) {
        throw new XMLStreamException("Expected a CHARACTER event");
    }
    DataHandlerReader dhr = getDataHandlerReader(reader);
    if (dhr != null && dhr.isBinary()) {
        DataHandler dh = dhr.getDataHandler();
        reader.next();
        return dh;
    } else {
        WritableBlob blob = new MemoryBlob();
        Writer out = new Base64DecodingOutputStreamWriter(blob.getOutputStream());
        try {
            writeTextTo(reader, out);
            // Take into account that in non coalescing mode, there may be additional
            // CHARACTERS events
            loop: while (true) {
                switch (reader.next()) {
                case XMLStreamConstants.CHARACTERS:
                    writeTextTo(reader, out);
                    break;
                case XMLStreamConstants.END_ELEMENT:
                    break loop;
                default:
                    throw new XMLStreamException("Expected a CHARACTER event");
                }
            }
            out.close();
        } catch (IOException ex) {
            throw new XMLStreamException("Error during base64 decoding", ex);
        }
        return new DataHandler(new BlobDataSource(blob, "application/octet-string"));
    }
}

From source file:it.greenvulcano.gvesb.virtual.utils.MimeMessageHelper.java

public MimeMessageHelper addAttachment(String name, String type, byte[] content) throws MessagingException {

    BodyPart attachmentPart = new MimeBodyPart();
    ByteArrayDataSource byteArrayDataSource = new ByteArrayDataSource(content, type);

    attachmentPart.setDataHandler(new DataHandler(byteArrayDataSource));
    attachmentPart.setFileName(name);//from  w w w  .  j  av a 2s  .c o  m

    attachmentPart.setDisposition(Part.ATTACHMENT);
    attachments.add(attachmentPart);
    return this;
}

From source file:org.wso2.carbon.cloud.gateway.agent.CGAgentUtils.java

private static OMNode readNonXML(URL url) throws CGException {

    try {/*  w  w w .ja  v  a  2s . c  o m*/
        // Open a new connection
        URLConnection newConnection = getURLConnection(url);
        if (newConnection == null) {
            if (log.isDebugEnabled()) {
                log.debug("Cannot create a URLConnection for given URL : " + url);
            }
            return null;
        }

        BufferedInputStream newInputStream = new BufferedInputStream(newConnection.getInputStream());

        OMFactory omFactory = OMAbstractFactory.getOMFactory();
        return omFactory.createOMText(
                new DataHandler(new SynapseBinaryDataSource(newInputStream, newConnection.getContentType())),
                true);

    } catch (IOException e) {
        throw new CGException("Error when getting a stream from resource's content", e);
    }
}

From source file:org.apache.camel.component.mail.MailBinding.java

protected String populateContentOnMimeMessage(MimeMessage part, MailConfiguration configuration,
        Exchange exchange) throws MessagingException, IOException {

    String contentType = determineContentType(configuration, exchange);

    if (LOG.isTraceEnabled()) {
        LOG.trace("Using Content-Type " + contentType + " for MimeMessage: " + part);
    }//from www  . j a  v  a  2s .  c o  m

    // always store content in a byte array data store to avoid various content type and charset issues
    DataSource ds = new ByteArrayDataSource(exchange.getIn().getBody(String.class), contentType);
    part.setDataHandler(new DataHandler(ds));

    // set the content type header afterwards
    part.setHeader("Content-Type", contentType);

    return contentType;
}

From source file:org.igov.io.mail.Mail.java

public Mail _Attach(DataSource oDataSource, String sFileName, String sDescription) {
    try {//from  w  w  w.  j  a  v a  2 s .  com
        MimeBodyPart oMimeBodyPart = new MimeBodyPart();
        oMimeBodyPart.setHeader("Content-Type", "multipart/mixed");
        oMimeBodyPart.setDataHandler(new DataHandler(oDataSource));
        oMimeBodyPart.setFileName(MimeUtility.encodeText(sFileName));
        oMultiparts.addBodyPart(oMimeBodyPart);
        LOG.info("(sFileName={}, sDescription={})", sFileName, sDescription);
    } catch (Exception oException) {
        LOG.error("FAIL: {} (sFileName={},sDescription={})", oException.getMessage(), sFileName, sDescription);
        LOG.trace("FAIL:", oException);
    }
    return this;
}

From source file:mitm.common.mail.MailUtils.java

/**
 * Converts any 8bit encoded parts to 7bit. Returns true if a part (or all parts) were converted from
 * 8bit to 7bit./*from  www. java 2  s . c o m*/
 * 
 * @param part
 * @throws MessagingException
 */
public static boolean convertTo7Bit(MimePart part) throws MessagingException, IOException {
    boolean converted = false;

    if (part.isMimeType("multipart/*")) {
        Multipart parts = (Multipart) part.getContent();

        int count = parts.getCount();

        for (int i = 0; i < count; i++) {
            boolean partConverted = convertTo7Bit((MimePart) parts.getBodyPart(i));

            if (partConverted) {
                converted = true;
            }
        }
    } else if ("8bit".equalsIgnoreCase(part.getEncoding())) {
        String encoding = part.isMimeType("text/*") ? "quoted-printable" : "base64";

        /*
         * We need to use a ByteArrayDataSource to make sure it will always be encoded
         */
        part.setDataHandler(
                new DataHandler(new ByteArrayDataSource(part.getInputStream(), part.getContentType())));

        part.setHeader("Content-Transfer-Encoding", encoding);
        part.addHeader("X-MIME-Autoconverted", "from 8bit to " + encoding + " by Djigzo");

        converted = true;
    }

    return converted;
}