330 lines
9.9 KiB
Java
330 lines
9.9 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.gcube.portlets.user.workspace.server.util;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.apache.commons.io.FilenameUtils;
|
|
import org.apache.tika.config.TikaConfig;
|
|
import org.apache.tika.detect.Detector;
|
|
import org.apache.tika.io.TikaInputStream;
|
|
import org.apache.tika.metadata.Metadata;
|
|
import org.apache.tika.mime.MediaType;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
|
|
// TODO: Auto-generated Javadoc
|
|
/**
|
|
* The Class MimeTypeUtil.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR (francesco.mangiacrapa@isti.cnr.it)
|
|
*
|
|
* Copied from org.gcube.common.homelibrary.util.MimeTypeUtil
|
|
* @author Federico De Faveri defaveri@isti.cnr.it
|
|
*
|
|
* Jul 5, 2019
|
|
*/
|
|
public class MimeTypeUtility {
|
|
|
|
private static final String DOT_STRING = ".";
|
|
|
|
protected static Logger logger = LoggerFactory.getLogger(MimeTypeUtility.class);
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static final String BINARY_MIMETYPE = "application/octet-stream";
|
|
public static final String[] ZIP_MIMETYPES = new String[] { "application/octet-stream", "application/x-compress",
|
|
"application/x-compressed", "application/x-zip-compressed", "application/x-gzip", "application/x-winzip",
|
|
"application/x-zip", "application/zip", "multipart/x-zip" };
|
|
|
|
protected static final Map<String, List<String>> mimetype_extension_map = new LinkedHashMap<String, List<String>>();
|
|
protected static final Map<String, String> extension_mimetype_map = new LinkedHashMap<String, String>();
|
|
protected static final Map<String, List<String>> preview_mimetype_extension_map = new LinkedHashMap<String, List<String>>();
|
|
|
|
static {
|
|
InputStream extensionToMimetype = MimeTypeUtility.class
|
|
.getResourceAsStream("/WsExtensionToMimeTypeMap.properties");
|
|
InputStream mimetypeToExtension = MimeTypeUtility.class
|
|
.getResourceAsStream("/WsMimeTypeToExtensionMap.properties");
|
|
InputStream previewMimeTypeToExtension = MimeTypeUtility.class
|
|
.getResourceAsStream("/PreviewMimeTypeToExtensionMap.properties");
|
|
try {
|
|
loadExtensions(extensionToMimetype);
|
|
loadMimeTypes(mimetypeToExtension);
|
|
loadPreviewMimeTypes(previewMimeTypeToExtension);
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load extensions.
|
|
*
|
|
* @param is the is
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
protected static void loadExtensions(InputStream is) throws IOException {
|
|
BufferedReader br = new BufferedReader(new InputStreamReader(is));
|
|
|
|
String line = br.readLine();
|
|
|
|
while (line != null) {
|
|
String[] split = line.split("=");
|
|
if (split.length == 2) {
|
|
String mimeType = split[0];
|
|
String extension = split[1];
|
|
extension_mimetype_map.put(extension, mimeType);
|
|
}
|
|
line = br.readLine();
|
|
}
|
|
br.close();
|
|
|
|
}
|
|
|
|
/**
|
|
* Load mime types.
|
|
*
|
|
* @param is the is
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
protected static void loadMimeTypes(InputStream is) throws IOException {
|
|
BufferedReader br = new BufferedReader(new InputStreamReader(is));
|
|
|
|
String line = br.readLine();
|
|
|
|
while (line != null) {
|
|
String[] split = line.split("=");
|
|
if (split.length == 2) {
|
|
String mimeType = split[0];
|
|
String extension = split[1];
|
|
List<String> toExtensions = mimetype_extension_map.get(mimeType);
|
|
if (toExtensions == null) {
|
|
toExtensions = new ArrayList<String>();
|
|
}
|
|
toExtensions.add(extension);
|
|
mimetype_extension_map.put(mimeType, toExtensions);
|
|
// mimetype_extension_map.put(mimeType, extension);
|
|
}
|
|
line = br.readLine();
|
|
}
|
|
br.close();
|
|
}
|
|
|
|
|
|
/**
|
|
* Load preview mime types.
|
|
*
|
|
* @param is the is
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
protected static void loadPreviewMimeTypes(InputStream is) throws IOException {
|
|
BufferedReader br = new BufferedReader(new InputStreamReader(is));
|
|
|
|
String line = br.readLine();
|
|
|
|
while (line != null) {
|
|
String[] split = line.split("=");
|
|
if (split.length == 2) {
|
|
String mimeType = split[0];
|
|
String extension = split[1];
|
|
List<String> toExtensions = preview_mimetype_extension_map.get(mimeType);
|
|
if (toExtensions == null) {
|
|
toExtensions = new ArrayList<String>();
|
|
}
|
|
toExtensions.add(extension);
|
|
preview_mimetype_extension_map.put(mimeType, toExtensions);
|
|
}
|
|
line = br.readLine();
|
|
}
|
|
br.close();
|
|
}
|
|
|
|
/**
|
|
* Gets the extension.
|
|
*
|
|
* @param mimeType the mime type.
|
|
* @return the related list of Extensions.
|
|
*/
|
|
public static List<String> getExtension(String mimeType) {
|
|
return mimetype_extension_map.get(mimeType);
|
|
}
|
|
|
|
/**
|
|
* Gets the name with extension.
|
|
*
|
|
* @param name the file name.
|
|
* @param mimeType the mime type.
|
|
* @return the right name.
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
public static String getNameWithExtension(String name, String mimeType) throws IOException {
|
|
|
|
logger.debug("Deriving the file extension for file name: " + name + ", with mimeType: " + mimeType);
|
|
|
|
if (mimeType == null || mimeType.isEmpty()) {
|
|
logger.debug("Input mime type is null or empty returning passed name: " + name);
|
|
return name;
|
|
}
|
|
|
|
String declaredExtension = FilenameUtils.getExtension(name);
|
|
logger.debug("The name " + name + " contains the extension: " + declaredExtension);
|
|
|
|
if (declaredExtension.equals("exe"))
|
|
return name;
|
|
|
|
List<String> extensions = MimeTypeUtility.getExtension(mimeType);
|
|
logger.trace("Extension/s available for input mimetype: " + mimeType + " into map is/are: " + extensions);
|
|
|
|
String toMimeTypeExtension = "";
|
|
if (extensions != null) {
|
|
toMimeTypeExtension = extensions.get(extensions.size() - 1); // I'm reading the last extension in the map
|
|
// (myme type - list of extensions)
|
|
logger.debug("Using the last extension read into list of available extensions: " + toMimeTypeExtension);
|
|
}
|
|
|
|
// MANAGING ALREADY DECLARED EXTENSION IN THE FILE NAME
|
|
if (!declaredExtension.isEmpty() && !toMimeTypeExtension.isEmpty()) {
|
|
String dEextL = declaredExtension.toLowerCase();
|
|
String mtExtL = toMimeTypeExtension.toLowerCase();
|
|
|
|
// The extension writes in the file name is matching the mime type extension
|
|
// declared in the map
|
|
if (dEextL.equals(mtExtL)) {
|
|
logger.trace("The Extension declared in the name " + name
|
|
+ " is matching derived mime type extension so returning the input name: " + name);
|
|
return name;
|
|
}
|
|
|
|
// if(!dEextL.trim().contains(" ")) {
|
|
// logger.trace("The Extension declared in the name "+name+" seems a valid suffix (without other spaces) so returning the input name: "+name);
|
|
// return name;
|
|
// }
|
|
|
|
logger.debug("No logic seems to match the extension declared in the name " + declaredExtension
|
|
+ " as a valid extension so I'm adding the extension derived from mime type map: "
|
|
+ toMimeTypeExtension);
|
|
}
|
|
|
|
// CHECKING THE FOLLOWING IN ORDER TO AVOID THE DOT AS LAST CHAR OF FILENAME
|
|
if (toMimeTypeExtension.isEmpty()) {
|
|
return name;
|
|
}
|
|
|
|
String fullname = String.format("%s%s%s", name, DOT_STRING, toMimeTypeExtension);
|
|
logger.trace("returning full name:" + fullname);
|
|
return fullname;
|
|
|
|
}
|
|
|
|
/**
|
|
* Check if the content type is a zip type.
|
|
*
|
|
* @param contentType the content type to check.
|
|
* @return <code>true</code> if is a zip file, <code>false</code> otherwise.
|
|
*/
|
|
public static boolean isZipContentType(String contentType) {
|
|
for (String zip_mimetype : ZIP_MIMETYPES)
|
|
if (zip_mimetype.equals(contentType))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get mime type by file.
|
|
*
|
|
* @param filenameWithExtension the filename with extension
|
|
* @param tmpFile the tmp file
|
|
* @return the mime type of the given file
|
|
*/
|
|
public static String getMimeType(String filenameWithExtension, File tmpFile) {
|
|
MediaType mediaType = null;
|
|
try {
|
|
|
|
TikaConfig config = TikaConfig.getDefaultConfig();
|
|
Detector detector = config.getDetector();
|
|
TikaInputStream stream = TikaInputStream.get(tmpFile);
|
|
Metadata metadata = new Metadata();
|
|
metadata.add(Metadata.RESOURCE_NAME_KEY, filenameWithExtension);
|
|
|
|
mediaType = detector.detect(stream, metadata);
|
|
|
|
} catch (IOException e) {
|
|
logger.error("Error detecting mime type for file " + filenameWithExtension);
|
|
}
|
|
|
|
return mediaType.getBaseType().toString();
|
|
}
|
|
|
|
/**
|
|
* Get mime type by inpustream.
|
|
*
|
|
* @param filenameWithExtension the filename with extension
|
|
* @param input the input
|
|
* @return the mime type of the given file
|
|
* @throws IOException Signals that an I/O exception has occurred.
|
|
*/
|
|
public static String getMimeType(String filenameWithExtension, InputStream input) throws IOException {
|
|
|
|
MediaType mediaType = null;
|
|
try {
|
|
TikaConfig config = TikaConfig.getDefaultConfig();
|
|
Detector detector = config.getDetector();
|
|
TikaInputStream stream = TikaInputStream.get(input);
|
|
Metadata metadata = new Metadata();
|
|
metadata.add(Metadata.RESOURCE_NAME_KEY, filenameWithExtension);
|
|
|
|
mediaType = detector.detect(stream, metadata);
|
|
|
|
} catch (IOException e) {
|
|
logger.error("Error detecting mime type for file " + filenameWithExtension);
|
|
} finally {
|
|
// if (file!=null)
|
|
// file.close();
|
|
}
|
|
|
|
return mediaType.getBaseType().toString();
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the mime type to extension map.
|
|
*
|
|
* @return the mime type to extension map
|
|
*/
|
|
public static Map<String, List<String>> getMimeTypeToExtensionMap() {
|
|
return mimetype_extension_map;
|
|
}
|
|
|
|
/**
|
|
* Gets the extension to mime type map.
|
|
*
|
|
* @return the extension to mime type map
|
|
*/
|
|
public static Map<String, String> getExtensionToMimeTypeMap() {
|
|
return extension_mimetype_map;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the preview mimetype extension map with the
|
|
* mime types allowed for preview displaying
|
|
*
|
|
* @return the preview mimetype extension map
|
|
*/
|
|
public static Map<String, List<String>> getPreviewMimetypeExtensionMap() {
|
|
return preview_mimetype_extension_map;
|
|
}
|
|
|
|
}
|