@Test
public void mimetype_with_value_set_from_mimetype() throws Exception {
final MimeType value = new MimeType(SOME_IMAGE_MIME_TYPE);
imageBuilder.setMimeType(value);
assertEquals(
"Mime Type should have been set correctly.", value.toString(), imageBuilder.getMimeType());
}
private void setMimeType(CMVisual mediaItem, MediaContent mediaContent) {
try {
String type = mediaItem.getData().getContentType().toString();
MimeType mimeType = new MimeType(type);
mediaContent.setMedium(mimeType.getPrimaryType());
mediaContent.setType(mimeType.toString());
} catch (MimeTypeParseException e) {
LOG.error("Cannot create mimetype for " + mediaItem, e);
}
}
public DataSourceSource(DataSource source) throws MimeTypeParseException {
this.source = source;
String ct = source.getContentType();
if (ct == null) {
charset = null;
} else {
MimeType mimeType = new MimeType(ct);
this.charset = mimeType.getParameter("charset");
}
}
@Override
protected void verifyMessage(MimeMultipart content) throws Exception {
assertEquals(3, content.getCount());
verifyMessage((String) content.getBodyPart(0).getContent());
List<String> expectedTypes = Arrays.asList("text/plain", "text/xml");
for (int i = 0; i < 3; i++) {
BodyPart part = content.getBodyPart(i);
String type = part.getContentType();
MimeType mt = new MimeType(type);
assertTrue(expectedTypes.contains(mt.getPrimaryType() + "/" + mt.getSubType()));
}
}
private boolean matchesContentType(IResultSetContext context) {
String documentType = context.getDocumentContentType();
if (contentTypes.isEmpty() || CommonUtils.isEmpty(documentType)) {
return false;
}
for (MimeType mimeType : contentTypes) {
try {
if (mimeType.match(documentType)) {
return true;
}
} catch (MimeTypeParseException e) {
log.warn("Bad document content type: " + documentType, e);
}
}
return false;
}
/**
* Load MIMEType and corresponding extension.
*
* @param aLine the a line
*/
protected void processLine(String aLine) {
aLine = aLine.toLowerCase();
int p = aLine.indexOf("=");
String ext = aLine.substring(0, p);
String mimetype = aLine.substring(p + 1);
try {
MimeType mimeType = new MimeType(mimetype);
String mode = mimeType.getParameter(ExtendedMimeTypeResolver.X_TYPE_MODE);
if (mode != null && mode.length() > 0) {
String baseType = mimeType.getBaseType();
Set<String> modeList = modes.get(baseType);
if (modeList == null) {
modeList = new LinkedHashSet<String>();
}
modeList.add(mode);
modes.put(baseType, modeList);
}
} catch (MimeTypeParseException e) {
LOG.warn("Error parsing mimetype " + mimetype + ": " + e.getMessage());
}
// add mimetype
List<String> values = mimeTypes.get(ext);
if (values == null) {
values = new ArrayList<String>();
mimeTypes.put(ext, values);
}
values.add(mimetype);
// add extension
values = extentions.get(mimetype);
if (values == null) {
values = new ArrayList<String>();
extentions.put(mimetype, values);
}
values.add(ext);
}
/**
* Return optional representation (UI) mode parameter (x-type-mode) for given MIME type or/and a
* file name. If type is <code>null</code> then the type will be defined from given file name
* first. If mode cannot be determined for given type and file name not <code>null</code>, then an
* attempt will be tried for a type defined for this name. Method returns <code>null</code> if
* mode cannot be determined from given parameters.
*
* @param type {@link String} a MIME type string or <code>null</code>
* @param name {@link String} a file name or <code>null</code>
* @return {@link String} with UI mode for given MIME type or <code>null</code> if mode cannot be
* determined
*/
public String getMimeTypeMode(String type, String name) {
if (type == null && name != null) {
type = getMimeType(name);
}
if (type != null) {
try {
boolean tryResolved;
do {
tryResolved = false;
MimeType mimeType = new MimeType(type);
String mode = mimeType.getParameter(ExtendedMimeTypeResolver.X_TYPE_MODE);
if (mode == null || mode.length() == 0) {
// try in this resolved map
Set<String> modeList = modes.get(mimeType.getBaseType());
if (modeList != null && modeList.size() == 1) {
// if have one-to-one relation - OK, else will try by filename
return modeList.iterator().next();
} else if (name != null) {
// try with a type resolved from given filename
type = getMimeType(name);
tryResolved = true;
name = null; // null to do not repeat this attempt
} else if (modeList != null && modeList.size() > 0) {
// worse case: we have several modes for given type and need choose... first one
return modeList.iterator().next();
}
} else {
return mode;
}
} while (type != null && tryResolved);
} catch (MimeTypeParseException e) {
LOG.warn("Error parsing mimetype " + type + ": " + e.getMessage());
}
}
return null;
}
/** Insert or delete RDF statements in a model at a URL. */
public void modifyModel(long model, Statements statements, boolean occurs)
throws ResolverException {
if (logger.isDebugEnabled()) {
logger.debug("Modify URL model " + model);
}
try {
FullTextStringIndex stringIndex = getFullTextStringIndex(model);
statements.beforeFirst();
while (statements.next()) {
Node subjectNode = resolverSession.globalize(statements.getSubject());
// Do not insert the triple if it contains a blank node in subject.
if (subjectNode instanceof BlankNode) {
if (logger.isInfoEnabled()) {
logger.info(statements.getSubject() + " is blank node; ignoring Lucene insert.");
}
continue;
}
Node predicateNode = resolverSession.globalize(statements.getPredicate());
Node objectNode = resolverSession.globalize(statements.getObject());
// Get the subject's string value.
String subject = ((URIReference) subjectNode).getURI().toString();
// Predicates can only ever be URIReferences.
String predicate = ((URIReference) predicateNode).getURI().toString();
if (objectNode instanceof URIReference) {
URIReference objectURI = (URIReference) objectNode;
String resource = objectURI.getURI().toString();
try {
// Assert or deny the statement in the Lucene model
if (occurs) {
InputStream input = null;
Reader reader = null;
try {
// Connect to the resource's content
URLConnection connection = objectURI.getURI().toURL().openConnection();
String contentType = connection.getContentType();
if (logger.isDebugEnabled()) {
logger.debug("Content type of resource is " + contentType);
}
MimeType contentMimeType;
try {
contentMimeType = new MimeType(contentType);
} catch (MimeTypeParseException e) {
logger.warn("\"" + contentType + "\" didn't parse as MIME type", e);
try {
contentMimeType = new MimeType("content", "unknown");
} catch (MimeTypeParseException em) {
throw new ResolverException("Failed to create mime-type", em);
}
}
assert contentMimeType != null;
// If no character encoding is specified, guess at Latin-1
String charSet = contentMimeType.getParameter("charset");
if (charSet == null) {
charSet = "ISO8859-1";
}
assert charSet != null;
// Get the content, performing appropriate character encoding
input = connection.getInputStream();
reader = new InputStreamReader(input, charSet);
// Add a filter if the content type is text/html, to strip out
// HTML keywords that will clutter the index
try {
if (contentMimeType.match(new MimeType("text", "html"))) {
reader = HtmlToTextConverter.convert(reader);
}
} catch (MimeTypeParseException em) {
throw new ResolverException("Failed to create mime-type", em);
}
if (logger.isDebugEnabled()) {
logger.debug("Inserting " + subject + " " + predicate + " " + resource);
}
if (!stringIndex.add(subject, predicate, resource, reader)) {
logger.warn(
"Unable to add {"
+ subject
+ ", "
+ predicate
+ ", "
+ resource
+ "} to full text string index");
}
} catch (MalformedURLException e) {
logger.info(resource + " is not a URL; ignoring Lucene insert");
} catch (IOException e) {
throw new ResolverException("Can't obtain content of " + resource, e);
} catch (org.mulgara.util.conversion.html.ParseException e) {
throw new ResolverException("Couldn't parse content of " + resource, e);
} finally {
try {
if (reader != null) reader.close();
else if (input != null) input.close();
} catch (IOException e) {
logger.warn("Ignoring error closing resource content", e);
}
}
} else { // (!occurs)
if (logger.isDebugEnabled()) {
logger.debug("Deleting " + subject + " " + predicate + " " + resource);
}
if (!stringIndex.remove(subject, predicate, resource)) {
logger.warn(
"Unable to remove {"
+ subject
+ ", "
+ predicate
+ ", "
+ resource
+ "} from full text string index");
}
}
} catch (FullTextStringIndexException e) {
throw new ResolverException("Unable to modify full text index\n" + new StackTrace(e));
}
} else if (objectNode instanceof Literal) {
Literal objectLiteral = (Literal) objectNode;
String literal = objectLiteral.getLexicalForm();
// Insert the statement into the text index
try {
if (occurs) {
if (logger.isDebugEnabled()) {
logger.debug("Inserting " + subject + " " + predicate + " " + literal);
}
if (!stringIndex.add(subject, predicate, literal)) {
logger.warn(
"Unable to add {"
+ subject
+ ", "
+ predicate
+ ", "
+ literal
+ "} to full text string index");
}
} else {
if (logger.isDebugEnabled()) {
logger.debug("Deleting " + subject + " " + predicate + " " + literal);
}
if (!stringIndex.remove(subject, predicate, literal)) {
logger.warn(
"Unable to remove {"
+ subject
+ ", "
+ predicate
+ ", "
+ literal
+ "} from full text string index");
}
}
} catch (FullTextStringIndexException e) {
throw new ResolverException(
"Unable to "
+ (occurs ? "add" : "delete")
+ "'"
+ literal
+ "' to full text string index\n"
+ new StackTrace(e));
}
} else {
if (logger.isInfoEnabled()) {
logger.info(objectNode + " is blank node; ignoring Lucene insert.");
}
}
}
} catch (TuplesException et) {
throw new ResolverException("Error fetching statements", et);
} catch (GlobalizeException eg) {
throw new ResolverException("Error localizing statements", eg);
} catch (IOException ioe) {
throw new ResolverException("Failed to open string index", ioe);
} catch (FullTextStringIndexException ef) {
throw new ResolverException("Error in string index\n" + new StackTrace(ef));
}
}
/**
* Returns the must probable resource type for a MimeType.
*
* @param mimeType
* @return
*/
public static String getResourceType(final MimeType mimeType) {
final String result = DEFAULT_FILE_EXTENSIONS.get(mimeType.toString());
return result != null ? result : DEFAULT_FILE_EXTENSION;
}
