javax.activation.FileTypeMap Java Examples

/**
 * Get the Content type for this file
 *
 * @return Http Response content type
 */
public String getContentType() {
    String contentType;
    if (outputFormat != null) {
        contentType = FileTypeMap.getDefaultFileTypeMap().getContentType(fullName + "." + outputFormat);
    } else {
        contentType = FileTypeMap.getDefaultFileTypeMap().getContentType(fullName);
    }


    if (contentType != null && contentType.startsWith("text")) {
        contentType += ";charset=" + CHARSET;
    }

    return (contentType != null) ? contentType : "application/octet-stream";
}
 

@Test
public void javaMailSenderWithMimeMessageHelperAndSpecificEncoding() throws MessagingException {
	MockJavaMailSender sender = new MockJavaMailSender();
	sender.setHost("host");
	sender.setUsername("username");
	sender.setPassword("password");

	MimeMessageHelper message = new MimeMessageHelper(sender.createMimeMessage(), "UTF-8");
	assertEquals("UTF-8", message.getEncoding());
	FileTypeMap fileTypeMap = new ConfigurableMimeFileTypeMap();
	message.setFileTypeMap(fileTypeMap);
	assertEquals(fileTypeMap, message.getFileTypeMap());

	message.setTo("[email protected]");
	sender.send(message.getMimeMessage());

	assertEquals("host", sender.transport.getConnectedHost());
	assertEquals("username", sender.transport.getConnectedUsername());
	assertEquals("password", sender.transport.getConnectedPassword());
	assertTrue(sender.transport.isCloseCalled());
	assertEquals(1, sender.transport.getSentMessages().size());
	assertEquals(message.getMimeMessage(), sender.transport.getSentMessage(0));
}
 

@Test
public void javaMailSenderWithMimeMessageHelperAndDefaultEncoding() throws MessagingException {
	MockJavaMailSender sender = new MockJavaMailSender();
	sender.setHost("host");
	sender.setUsername("username");
	sender.setPassword("password");
	sender.setDefaultEncoding("UTF-8");

	FileTypeMap fileTypeMap = new ConfigurableMimeFileTypeMap();
	sender.setDefaultFileTypeMap(fileTypeMap);
	MimeMessageHelper message = new MimeMessageHelper(sender.createMimeMessage());
	assertEquals("UTF-8", message.getEncoding());
	assertEquals(fileTypeMap, message.getFileTypeMap());

	message.setTo("[email protected]");
	sender.send(message.getMimeMessage());

	assertEquals("host", sender.transport.getConnectedHost());
	assertEquals("username", sender.transport.getConnectedUsername());
	assertEquals("password", sender.transport.getConnectedPassword());
	assertTrue(sender.transport.isCloseCalled());
	assertEquals(1, sender.transport.getSentMessages().size());
	assertEquals(message.getMimeMessage(), sender.transport.getSentMessage(0));
}
 

@Override
public MimeMessage createMimeMessage() {

	// We have to use reflection as SmartMimeMessage is not package-private
	if (ClassUtils.isPresent(SMART_MIME_MESSAGE_CLASS_NAME,
			ClassUtils.getDefaultClassLoader())) {
		Class<?> smartMimeMessage = ClassUtils.resolveClassName(
				SMART_MIME_MESSAGE_CLASS_NAME, ClassUtils.getDefaultClassLoader());
		Constructor<?> constructor = ClassUtils.getConstructorIfAvailable(
				smartMimeMessage, Session.class, String.class, FileTypeMap.class);
		if (constructor != null) {
			Object mimeMessage = BeanUtils.instantiateClass(constructor, getSession(),
					this.defaultEncoding, this.defaultFileTypeMap);
			return (MimeMessage) mimeMessage;
		}
	}

	return new MimeMessage(getSession());
}
 

@Test
public void javaMailSenderWithMimeMessageHelperAndSpecificEncoding() throws MessagingException {
	MockJavaMailSender sender = new MockJavaMailSender();
	sender.setHost("host");
	sender.setUsername("username");
	sender.setPassword("password");

	MimeMessageHelper message = new MimeMessageHelper(sender.createMimeMessage(), "UTF-8");
	assertEquals("UTF-8", message.getEncoding());
	FileTypeMap fileTypeMap = new ConfigurableMimeFileTypeMap();
	message.setFileTypeMap(fileTypeMap);
	assertEquals(fileTypeMap, message.getFileTypeMap());

	message.setTo("[email protected]");
	sender.send(message.getMimeMessage());

	assertEquals("host", sender.transport.getConnectedHost());
	assertEquals("username", sender.transport.getConnectedUsername());
	assertEquals("password", sender.transport.getConnectedPassword());
	assertTrue(sender.transport.isCloseCalled());
	assertEquals(1, sender.transport.getSentMessages().size());
	assertEquals(message.getMimeMessage(), sender.transport.getSentMessage(0));
}
 

@Test
public void javaMailSenderWithMimeMessageHelperAndDefaultEncoding() throws MessagingException {
	MockJavaMailSender sender = new MockJavaMailSender();
	sender.setHost("host");
	sender.setUsername("username");
	sender.setPassword("password");
	sender.setDefaultEncoding("UTF-8");

	FileTypeMap fileTypeMap = new ConfigurableMimeFileTypeMap();
	sender.setDefaultFileTypeMap(fileTypeMap);
	MimeMessageHelper message = new MimeMessageHelper(sender.createMimeMessage());
	assertEquals("UTF-8", message.getEncoding());
	assertEquals(fileTypeMap, message.getFileTypeMap());

	message.setTo("[email protected]");
	sender.send(message.getMimeMessage());

	assertEquals("host", sender.transport.getConnectedHost());
	assertEquals("username", sender.transport.getConnectedUsername());
	assertEquals("password", sender.transport.getConnectedPassword());
	assertTrue(sender.transport.isCloseCalled());
	assertEquals(1, sender.transport.getSentMessages().size());
	assertEquals(message.getMimeMessage(), sender.transport.getSentMessage(0));
}
 

@Test
public void javaMailSenderWithMimeMessageHelperAndDefaultEncoding() throws MessagingException {
	MockJavaMailSender sender = new MockJavaMailSender();
	sender.setHost("host");
	sender.setUsername("username");
	sender.setPassword("password");
	sender.setDefaultEncoding("UTF-8");

	FileTypeMap fileTypeMap = new ConfigurableMimeFileTypeMap();
	sender.setDefaultFileTypeMap(fileTypeMap);
	MimeMessageHelper message = new MimeMessageHelper(sender.createMimeMessage());
	assertEquals("UTF-8", message.getEncoding());
	assertEquals(fileTypeMap, message.getFileTypeMap());

	message.setTo("[email protected]");
	sender.send(message.getMimeMessage());

	assertEquals("host", sender.transport.getConnectedHost());
	assertEquals("username", sender.transport.getConnectedUsername());
	assertEquals("password", sender.transport.getConnectedPassword());
	assertTrue(sender.transport.isCloseCalled());
	assertEquals(1, sender.transport.getSentMessages().size());
	assertEquals(message.getMimeMessage(), sender.transport.getSentMessage(0));
}
 

@Test
public void javaMailSenderWithMimeMessageHelperAndSpecificEncoding() throws MessagingException {
	MockJavaMailSender sender = new MockJavaMailSender();
	sender.setHost("host");
	sender.setUsername("username");
	sender.setPassword("password");

	MimeMessageHelper message = new MimeMessageHelper(sender.createMimeMessage(), "UTF-8");
	assertEquals("UTF-8", message.getEncoding());
	FileTypeMap fileTypeMap = new ConfigurableMimeFileTypeMap();
	message.setFileTypeMap(fileTypeMap);
	assertEquals(fileTypeMap, message.getFileTypeMap());

	message.setTo("[email protected]");
	sender.send(message.getMimeMessage());

	assertEquals("host", sender.transport.getConnectedHost());
	assertEquals("username", sender.transport.getConnectedUsername());
	assertEquals("password", sender.transport.getConnectedPassword());
	assertTrue(sender.transport.isCloseCalled());
	assertEquals(1, sender.transport.getSentMessages().size());
	assertEquals(message.getMimeMessage(), sender.transport.getSentMessage(0));
}
 

protected void onFinished() {
	org.hibernate.Session hibSession = TaskExecutionDAO.getInstance().createNewSession();
	Transaction tx = hibSession.beginTransaction();
	try {
		TaskExecution execution = TaskExecutionDAO.getInstance().get(getTaskExecutionId(), hibSession);
		if (execution != null) {
			execution.setFinishedDate(new Date());
			execution.setExecutionStatus(hasError() ? ExecutionStatus.FAILED.ordinal() : ExecutionStatus.FINISHED.ordinal());
			execution.setStatusMessageCheckLength(status());
			execution.setLogFile(createGson().toJson(getLog()));
			if (output() != null && output().exists()) {
				execution.setOutputName(getOutputName());
				execution.setOutputContentType(FileTypeMap.getDefaultFileTypeMap().getContentType(output()));
				FileInputStream is = new FileInputStream(output());
				try {
					execution.setOutputFile(IOUtils.toByteArray(is));
				} finally {
					is.close();
				}
			}
			hibSession.saveOrUpdate(execution);
		}
		hibSession.flush();
		tx.commit();
	} catch (Exception e) {
		tx.rollback();
	} finally {
		hibSession.close();
	}
}
 

private static void initFileTypeMap() {
    fileTypeMap = new MimetypesFileTypeMap();

    // Additional MIME types
    fileTypeMap.addMimeTypes("application/atom+xml atom");
    fileTypeMap.addMimeTypes("application/msword doc dot");
    fileTypeMap.addMimeTypes("application/mspowerpoint ppt pot");
    fileTypeMap.addMimeTypes("application/msexcel xls");
    fileTypeMap.addMimeTypes("application/pdf pdf");
    fileTypeMap.addMimeTypes("application/rdf+xml rdf rss");
    fileTypeMap.addMimeTypes("application/x-vnd.openxmlformat docx docm dotx dotm");
    fileTypeMap.addMimeTypes("application/x-vnd.openxmlformat xlsx xlsm");
    fileTypeMap.addMimeTypes("application/x-vnd.openxmlformat pptx pptm potx");
    fileTypeMap.addMimeTypes("application/x-javascript js");
    fileTypeMap.addMimeTypes("application/x-rar-compressed rar");
    fileTypeMap.addMimeTypes("application/x-textedit bat cmd");
    fileTypeMap.addMimeTypes("application/zip zip");
    fileTypeMap.addMimeTypes("audio/mpeg mp3");
    fileTypeMap.addMimeTypes("image/bmp bmp");
    fileTypeMap.addMimeTypes("image/gif gif");
    fileTypeMap.addMimeTypes("image/jpeg jpg jpeg jpe");
    fileTypeMap.addMimeTypes("image/png png");
    fileTypeMap.addMimeTypes("text/css css");
    fileTypeMap.addMimeTypes("text/csv csv");
    fileTypeMap.addMimeTypes("text/html htm html");
    fileTypeMap.addMimeTypes("text/xml xml");
    fileTypeMap.addMimeTypes("video/quicktime qt mov moov");
    fileTypeMap.addMimeTypes("video/mpeg mpeg mpg mpe mpv vbs mpegv");
    fileTypeMap.addMimeTypes("video/msvideo avi");
    fileTypeMap.addMimeTypes("video/mp4 mp4");
    fileTypeMap.addMimeTypes("video/ogg ogg");

    FileTypeMap.setDefaultFileTypeMap(fileTypeMap);
}
 

/**
 * Introduced to dispel claims in a thread on Stack Overflow:
 * <a href="http://stackoverflow.com/questions/22986109/testing-spring-managed-servlet">Testing Spring managed servlet</a>
 */
@Test
public void getMimeTypeWithCustomConfiguredType() {
	FileTypeMap defaultFileTypeMap = FileTypeMap.getDefaultFileTypeMap();
	assertThat(defaultFileTypeMap, instanceOf(MimetypesFileTypeMap.class));
	MimetypesFileTypeMap mimetypesFileTypeMap = (MimetypesFileTypeMap) defaultFileTypeMap;
	mimetypesFileTypeMap.addMimeTypes("text/enigma    enigma");
	assertEquals("text/enigma", sc.getMimeType("filename.enigma"));
}
 

/**
 * Return the delegate FileTypeMap, compiled from the mappings in the mapping file
 * and the entries in the {@code mappings} property.
 * @see #setMappingLocation
 * @see #setMappings
 * @see #createFileTypeMap
 */
protected final FileTypeMap getFileTypeMap() {
	if (this.fileTypeMap == null) {
		try {
			this.fileTypeMap = createFileTypeMap(this.mappingLocation, this.mappings);
		}
		catch (IOException ex) {
			throw new IllegalStateException(
					"Could not load specified MIME type mapping file: " + this.mappingLocation, ex);
		}
	}
	return this.fileTypeMap;
}
 

/**
 * Return the delegate FileTypeMap, compiled from the mappings in the mapping file
 * and the entries in the {@code mappings} property.
 * @see #setMappingLocation
 * @see #setMappings
 * @see #createFileTypeMap
 */
protected final FileTypeMap getFileTypeMap() {
	if (this.fileTypeMap == null) {
		try {
			this.fileTypeMap = createFileTypeMap(this.mappingLocation, this.mappings);
		}
		catch (IOException ex) {
			throw new IllegalStateException(
					"Could not load specified MIME type mapping file: " + this.mappingLocation, ex);
		}
	}
	return this.fileTypeMap;
}
 

/**
 * Create a new SmartMimeMessage.
 * @param session the JavaMail Session to create the message for
 * @param defaultEncoding the default encoding, or {@code null} if none
 * @param defaultFileTypeMap the default FileTypeMap, or {@code null} if none
 */
public SmartMimeMessage(
		Session session, @Nullable String defaultEncoding, @Nullable FileTypeMap defaultFileTypeMap) {

	super(session);
	this.defaultEncoding = defaultEncoding;
	this.defaultFileTypeMap = defaultFileTypeMap;
}
 

public ByteArrayDataSource(File file) throws FileNotFoundException, IOException {
	iName = file.getName();
	iContentType = FileTypeMap.getDefaultFileTypeMap().getContentType(file);
	FileInputStream is = new FileInputStream(file);
	try {
		iData = IOUtils.toByteArray(is);
	} finally {
		is.close();
	}
}
 

private void addAttachments( Enumeration<fileAttachment> _attach, Multipart _parent, boolean _isInline ) throws MessagingException{
	while ( _attach.hasMoreElements() ){
		fileAttachment nextFile = _attach.nextElement();
		FileDataSource fds 			= new FileDataSource( nextFile.getFilepath() );
		String mimeType = nextFile.getMimetype();
		if (mimeType == null){
			// if mime type not supplied then auto detect
			mimeType = FileTypeMap.getDefaultFileTypeMap().getContentType(nextFile.getFilepath());
     }else{
			// since mime type is not null then it the mime type has been set manually therefore
			// we need to ensure that any call to the underlying FileDataSource.getFileTypeMap()
			// returns a FileTypeMap that will map to this type
			fds.setFileTypeMap(new CustomFileTypeMap(mimeType));
		}
		
		String filename = cleanName(fds.getName());
		try {
			// encode the filename to ensure that it contains US-ASCII characters only
			filename = MimeUtility.encodeText( filename, "utf-8", "b" );
		} catch (UnsupportedEncodingException e5) {
			// shouldn't occur
		}
	  MimeBodyPart mimeAttach	= new MimeBodyPart();
	  mimeAttach.setDataHandler( new DataHandler(fds) );
		mimeAttach.setFileName( filename );

		ContentType ct = new ContentType(mimeType);
		ct.setParameter("name", filename );
		
		mimeAttach.setHeader("Content-Type", ct.toString() );

		if ( _isInline ){
       mimeAttach.setDisposition( "inline" );
       mimeAttach.addHeader( "Content-id", "<" + nextFile.getContentid() + ">" );
		}
     
		_parent.addBodyPart(mimeAttach);
	}
}
 

/**
 * Return the delegate FileTypeMap, compiled from the mappings in the mapping file
 * and the entries in the {@code mappings} property.
 * @see #setMappingLocation
 * @see #setMappings
 * @see #createFileTypeMap
 */
protected final FileTypeMap getFileTypeMap() {
	if (this.fileTypeMap == null) {
		try {
			this.fileTypeMap = createFileTypeMap(this.mappingLocation, this.mappings);
		}
		catch (IOException ex) {
			throw new IllegalStateException(
					"Could not load specified MIME type mapping file: " + this.mappingLocation, ex);
		}
	}
	return this.fileTypeMap;
}
 

@Test
void createMimeMessage_withCustomFileTypeMap_fileTypeMapIsAvailableInMailSender() {
	// Arrange
	SimpleEmailServiceJavaMailSender mailSender = new SimpleEmailServiceJavaMailSender(
			null);
	mailSender.setDefaultFileTypeMap(FileTypeMap.getDefaultFileTypeMap());

	// Act
	MimeMessage mimeMessage = mailSender.createMimeMessage();
	MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage);

	// Assert
	assertThat(mimeMessageHelper.getFileTypeMap()).as("ISO-8859-1").isNotNull();
}
 

/**
 * Create a new SmartMimeMessage.
 * @param session the JavaMail Session to create the message for
 * @param defaultEncoding the default encoding, or {@code null} if none
 * @param defaultFileTypeMap the default FileTypeMap, or {@code null} if none
 */
public SmartMimeMessage(
		Session session, @Nullable String defaultEncoding, @Nullable FileTypeMap defaultFileTypeMap) {

	super(session);
	this.defaultEncoding = defaultEncoding;
	this.defaultFileTypeMap = defaultFileTypeMap;
}
 

private void updateMediaEntryAppLinks(final Entry entry, final String fileName, final boolean singleEntry) {

        // TODO: figure out why PNG is missing from Java MIME types
        final FileTypeMap map = FileTypeMap.getDefaultFileTypeMap();
        if (map instanceof MimetypesFileTypeMap) {
            try {
                ((MimetypesFileTypeMap) map).addMimeTypes("image/png png PNG");
            } catch (final Exception ignored) {
            }
        }
        entry.setId(getEntryMediaViewURI(fileName));
        entry.setTitle(fileName);
        entry.setUpdated(new Date());

        final List<Link> otherlinks = new ArrayList<Link>();
        entry.setOtherLinks(otherlinks);

        final Link editlink = new Link();
        editlink.setRel("edit");
        editlink.setHref(getEntryEditURI(fileName, relativeURIs, singleEntry));
        otherlinks.add(editlink);

        final Link editMedialink = new Link();
        editMedialink.setRel("edit-media");
        editMedialink.setHref(getEntryMediaEditURI(fileName, relativeURIs, singleEntry));
        otherlinks.add(editMedialink);

        final Content content = entry.getContents().get(0);
        content.setSrc(getEntryMediaViewURI(fileName));
        final List<Content> contents = new ArrayList<Content>();
        contents.add(content);
        entry.setContents(contents);
    }
 

/**
 * Return the delegate FileTypeMap, compiled from the mappings in the mapping file
 * and the entries in the {@code mappings} property.
 * @see #setMappingLocation
 * @see #setMappings
 * @see #createFileTypeMap
 */
protected final FileTypeMap getFileTypeMap() {
	if (this.fileTypeMap == null) {
		try {
			this.fileTypeMap = createFileTypeMap(this.mappingLocation, this.mappings);
		}
		catch (IOException ex) {
			throw new IllegalStateException(
					"Could not load specified MIME type mapping file: " + this.mappingLocation, ex);
		}
	}
	return this.fileTypeMap;
}
 

@Override
public String getContentType() {
    if (typeMap == null) {
        return FileTypeMap.getDefaultFileTypeMap().getContentType(fileName);
    } else {
        return typeMap.getContentType(fileName);
    }
}
 

/** {@inheritDoc} */
@Override
public DataSource resolve(final String resourceLocation, final boolean isLenient) throws IOException
{
    DataSource result = null;

    try
    {
        if (!isCid(resourceLocation) && !isHttpUrl(resourceLocation))
        {
            final String mimeType = FileTypeMap.getDefaultFileTypeMap().getContentType(resourceLocation);
            final String resourceName = getResourceName(resourceLocation);
            final InputStream is = DataSourceClassPathResolver.class.getResourceAsStream(resourceName);

            if (is != null)
            {
                try
                {
                    final ByteArrayDataSource ds = new ByteArrayDataSource(is, mimeType);
                    // EMAIL-125: set the name of the DataSource to the normalized resource URL
                    // similar to other DataSource implementations, e.g. FileDataSource, URLDataSource
                    ds.setName(DataSourceClassPathResolver.class.getResource(resourceName).toString());
                    result = ds;
                }
                finally
                {
                    is.close();
                }
            }
            else
            {
                if (isLenient)
                {
                    return null;
                }
                throw new IOException("The following class path resource was not found : " + resourceLocation);
            }
        }


        return result;
    }
    catch (final IOException e)
    {
        if (isLenient)
        {
            return null;
        }
        throw e;
    }
}
 

public static String getMimeType(String filePath) {
	return FileTypeMap.getDefaultFileTypeMap().getContentType(filePath);
}
 

@Override
public void init () throws ServletException
{
    super.init ();
    this.fileTypeMap = FileTypeMap.getDefaultFileTypeMap ();
}
 

CustomMimeMessage(Session session, String defaultEncoding, FileTypeMap defaultFileTypeMap) {
    super(session);
    this.defaultEncoding = defaultEncoding;
    this.defaultFileTypeMap = defaultFileTypeMap;
}
 

/**
 * Return the {@code FileTypeMap} used by this MimeMessageHelper.
 */
public FileTypeMap getFileTypeMap() {
	return this.fileTypeMap;
}
 

/**
 * Return the default FileTypeMap of this message, or {@code null} if none.
 */
public final FileTypeMap getDefaultFileTypeMap() {
	return this.defaultFileTypeMap;
}
 

public final FileTypeMap getDefaultFileTypeMap() {
    return this.defaultFileTypeMap;
}
 

public static String getMimeType(String filePath) {
	return FileTypeMap.getDefaultFileTypeMap().getContentType(filePath);
}