org.apache.james.mime4j.stream.BodyDescriptor Java Examples

@Override
public void body(BodyDescriptor bd, InputStream is) throws MimeException,
        IOException {
    String r = "";
    byte[] buffer = new byte[200];
    String s;
    int len;
    try {
        while ((len = is.read(buffer)) != -1) {
            if (len != 200) {
                byte buffer2[] = new byte[len];
                System.arraycopy(buffer, 0, buffer2, 0, len);
                s = new String(buffer2);
            } else {
                s = new String(buffer);
            }
            if (s != null)
                r += s;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    mailInfo.body = r;
    //System.out.println("body");
    //System.out.println(r);
}
 

@Test
public void shouldSetSequenceWithEachNewPart() throws Exception{

    BodyDescriptor bodyMock = mock(BodyDescriptor.class);
    ByteArrayInputStream streamMock = new ByteArrayInputStream(new byte[] {});

    MessageContentExtractor extractor = new MessageContentExtractor();

    extractor.startHeader();
    extractor.body(bodyMock, streamMock);
    assertThat(getCurrentSequence(extractor)).containsExactly(1);

    extractor.startHeader();
    extractor.body(bodyMock, streamMock);
    assertThat(getCurrentSequence(extractor)).containsExactly(1, 2);

    extractor.startHeader();
    extractor.body(bodyMock, streamMock);
    assertThat(getCurrentSequence(extractor)).containsExactly(1, 2, 3);
}
 

public static String getAttachmentNameFromDispositionParameters(BodyDescriptor bd) {
    //Refer RFC : 2047 for mime word decoding
    //Refer RFC : 2183 for Content-Disposition Header Field
    String attachmentName = null;
    if (bd instanceof MaximalBodyDescriptor) {
        attachmentName = getDecodedWord(((MaximalBodyDescriptor) bd).getContentDispositionFilename());
        if (StringUtils.isEmpty(attachmentName)) {
            //Handling case where RFC 2183 is not properly implemented by tech.blueglacier.email creating client.
            attachmentName = getDecodedWord(((MaximalBodyDescriptor) bd).getContentDispositionParameters().get("name"));
        }
        //Added case for supporting RFC 2184 'Parameter Value Character Set and Language Information' 
        // this is currently not supported in mime4j (version 0.7.2)
        if (StringUtils.isEmpty(attachmentName)) {
            attachmentName = getDecodedDispositionFileName(bd);
        }
    }
    return attachmentName;
}
 

private AbstractContentHandler createMdnContentHandler(final ResultCollector resultCollector) {
    return new AbstractContentHandler() {
        @Override
        public void body(BodyDescriptor bodyDescriptor, InputStream inputStream) throws MimeException, IOException {
            if (bodyDescriptor.getMimeType().equalsIgnoreCase("message/disposition-notification")) {
                resultCollector.setResult(MDNReportParser.parse(inputStream, bodyDescriptor.getCharset())
                    .map(report -> report.getDispositionField().getSendingMode() == DispositionSendingMode.Automatic)
                    .getOrElse(() -> false));
            }
        }
    };
}
 

public void fillEmailContents(BodyDescriptor bd, InputStream is){
	LOGGER.info("mime part received");
	if(addPlainTextEmailBody(bd,is)){}
	else if(addHTMLEmailBody(bd,is)){}
	else if(addCalendar(bd,is)){}
	else{
		addAttachments(bd,is);
	}
}
 

private boolean addCalendar(BodyDescriptor bd, InputStream is) {
	boolean isBodySet = false;
	BodyDescriptor calendarBodyDescriptor = bd;
	if(calendarBody == null){
		if(isCalendarBody(calendarBodyDescriptor)){
			calendarBody = new CalendarBody(bd,is);
			isBodySet = true;
			LOGGER.info("Email calendar body identified");
		}
	}
	
	return isBodySet;
}
 

public static String getAttachmentName(BodyDescriptor bd){		
	// Content tech.blueglacier.disposition 'filename' is more standard, so it's taken as default first
	String attachmentName = Common.getAttachmentNameFromDispositionParameters(bd);
	if(attachmentName == null || attachmentName.isEmpty()){			
		// Content type 'name' is other alternative so it's taken as alternative too
		attachmentName = Common.getAttachmentNameFromContentTypeParmaeters(bd);			
	}		
	return attachmentName;		
}
 

private boolean addHTMLEmailBody(BodyDescriptor bd, InputStream is) {
	boolean isBodySet = false;
	BodyDescriptor emailHTMLBodyDescriptor = bd;
	if(htmlEmailBody == null){
		if(isHTMLBody(emailHTMLBodyDescriptor)){
			htmlEmailBody = new HtmlEmailBody(bd,is);
			isBodySet = true;
			LOGGER.info("Email html body identified");
		}
	}else{
		if(isHTMLBody(emailHTMLBodyDescriptor)){
			if(multipartStack.peek().getBodyDescriptor().getMimeType().equalsIgnoreCase("multipart/mixed")){
				InputStream mainInputStream;
				try {
					mainInputStream = concatInputStream(is, htmlEmailBody.getIs());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				htmlEmailBody.setIs(mainInputStream);
			}else{
				addAttachments(new HtmlEmailBody(bd,is));
			}
			isBodySet = true;
		}
	}		
	return isBodySet;
}
 

public static String getAttachmentNameFromContentTypeParmaeters(BodyDescriptor bd) {
	String attachmentName = null;
	if(bd instanceof MaximalBodyDescriptor){
		Map<String, String> contentTypeParameters = ((MaximalBodyDescriptor)bd).getContentTypeParameters();
		String nameKey = null;
		if(contentTypeParameters.containsKey(nameKey = "name") || contentTypeParameters.containsKey(nameKey = "NAME")
				|| contentTypeParameters.containsKey(nameKey = "Name")){
			attachmentName = contentTypeParameters.get(nameKey);
		}
		attachmentName = getDecodedWord(attachmentName);
	}
	return attachmentName;
}
 

private static String getDecodedDispositionFileName(BodyDescriptor bd){
	String attachmentName = null;
	try {
		attachmentName = ContentDispositionDecoder.decodeDispositionFileName(((MaximalBodyDescriptor)bd).getContentDispositionParameters());
	} catch (MimeException e) {
		throw new RuntimeException(e);
	}
	return attachmentName;
}
 

private boolean addPlainTextEmailBody(BodyDescriptor bd, InputStream is) {
	boolean isBodySet = false;
	BodyDescriptor emailPlainBodyDescriptor = bd;
	if(plainTextEmailBody == null){
		if(isPlainTextBody(emailPlainBodyDescriptor)){
			plainTextEmailBody = new PlainTextEmailBody(bd,is);
			isBodySet = true;
			LOGGER.info("Email plain text body identified");
		}
	}else{
		if(isPlainTextBody(emailPlainBodyDescriptor)){
			if(multipartStack.peek().getBodyDescriptor().getMimeType().equalsIgnoreCase("multipart/mixed")){
				InputStream mainInputStream;
				try {
					mainInputStream = concatInputStream(is,plainTextEmailBody.getIs());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				plainTextEmailBody.setIs(mainInputStream);
			}else{
				addAttachments(new PlainTextEmailBody(bd,is));
			}
			isBodySet = true;
		}
	}		
	return isBodySet;
}
 

@Override
public void body(BodyDescriptor bd, InputStream is) throws MimeException, IOException {
    // Gracefully switching off the case of email attached within an email
    if (email.getMessageStack().peek().getEmailMessageTypeHierarchy() == EmailMessageTypeHierarchy.parent) {
        email.fillEmailContents(bd, is);
    }
}
 

public BodyDescriptor getBd() {
    return bd;
}
 

@Override
public void startMultipart(BodyDescriptor bd) throws MimeException {
}
 

public void startMultipart(BodyDescriptor bd) throws MimeException {
    email.getMultipartStack().push(new MultipartType(bd));
}
 

public HtmlEmailBody(BodyDescriptor bd, InputStream is) {
	super(bd, is);
}
 

public Attachment(BodyDescriptor bd, InputStream is) {
    this.bd = bd;
    attachmentSize = 0;
    setIs(is);
}
 

public EmailAttachment(BodyDescriptor bd, InputStream is){
	super(bd, is);
}
 

private boolean isPlainTextBody(BodyDescriptor emailPlainBodyDescriptor) {
	String bodyName = Common.getAttachmentName(emailPlainBodyDescriptor);
	return (emailPlainBodyDescriptor.getMimeType().equalsIgnoreCase("text/plain") && bodyName == null);
}
 

private boolean isCalendarBody(BodyDescriptor emailCalendarBodyDescriptor) {
	String bodyName = Common.getAttachmentName(emailCalendarBodyDescriptor);
	return (emailCalendarBodyDescriptor.getMimeType().equalsIgnoreCase("text/calendar") && bodyName == null);
}
 

private boolean isHTMLBody(BodyDescriptor emailHTMLBodyDescriptor) {
	String bodyName = Common.getAttachmentName(emailHTMLBodyDescriptor);
	return (emailHTMLBodyDescriptor.getMimeType().equalsIgnoreCase("text/html") && bodyName == null);
}
 

private void addAttachments(BodyDescriptor bd, InputStream is) {
   attachments.add(new EmailAttachment(bd,is));
   LOGGER.info("Email attachment identified");
}
 

public CalendarBody(BodyDescriptor bd, InputStream is) {
	super(bd, is);
}
 

public BodyDescriptor getBodyDescriptor() {
	return bodyDiscriptor;
}
 

public MultipartType(BodyDescriptor bodyDescriptor){
	this.bodyDiscriptor = bodyDescriptor; 
}
 

public PlainTextEmailBody(BodyDescriptor bd, InputStream is) {
	super(bd, is);
}
 

@Override
public void body(BodyDescriptor bd, InputStream is) throws IOException {

    nextPotentialPart.setContent(is);
    bodyParts.addPart(nextPotentialPart);

}