@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; }