javax.activation.MimeTypeParseException Java Examples

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

@Test
public void testTypeFallback() throws MimeTypeParseException {
   MimeTypeMap<String> map = new MimeTypeMap<>();

  map.put( new MimeType( "text/xml" ), "text/xml" );
  map.put( new MimeType( "text/json" ), "text/json" );
  map.put( new MimeType( "text/*" ), "text/*" );

  map.put( new MimeType( "application/json" ), "text/json" );
  map.put( new MimeType( "application/*" ), "application/*" );

  map.put( new MimeType( "*/xml" ), "*/xml" );
  map.put( new MimeType( "*/json" ), "*/json" );
  map.put( new MimeType( "*/*" ), "*/*" );

  assertThat( map.get( "text/xml" ), is( "text/xml" ) );
  assertThat( map.get( "custom/xml" ), is( "*/xml" ) );
  assertThat( map.get( "text/custom" ), is( "text/*" ) );
  assertThat( map.get( "custom/custom" ), is( "*/*" ) );

}
 

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

public MimeType(String raw) throws MimeTypeParseException {
  javax.activation.MimeType parsed = new javax.activation.MimeType(raw);
  
  this.type = parsed.getPrimaryType();
  this.subtype = parsed.getSubType();
  
  parameters = new HashMap<String,String>();
  
  MimeTypeParameterList params = parsed.getParameters();
  
  Enumeration<String> paramNames = params.getNames();
  while (paramNames.hasMoreElements()) {
    String name = paramNames.nextElement();
    System.out.println(name+"/"+params.get(name));
    parameters.put(name, params.get(name));
  }
}
 

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

static MimeType calcExpectedMediaType(AnnotationSource primarySource,
                    ModelBuilder builder ) {
    XmlMimeType xmt = primarySource.readAnnotation(XmlMimeType.class);
    if(xmt==null)
        return null;

    try {
        return new MimeType(xmt.value());
    } catch (MimeTypeParseException e) {
        builder.reportError(new IllegalAnnotationException(
            Messages.ILLEGAL_MIME_TYPE.format(xmt.value(),e.getMessage()),
            xmt
        ));
        return null;
    }
}
 

private Optional<MimeType> getMimeTypeFromMessage(MimeMessage message) throws MessagingException {
    try {
        return Optional.of(new MimeType(message.getContentType()));
    } catch (MimeTypeParseException e) {
        LOGGER.warn("Error while parsing message's mimeType {}", message.getContentType(), e);
        return Optional.empty();
    }
}
 

@Test
public void fromSteam() throws MimeTypeDetectionException, MimeTypeParseException, IOException {
	when(tikaInstance.detect(any(InputStream.class))).thenReturn("application/json");
	tika = new TikaProvider(tikaInstance, true);
	MimeType mimetype = tika.detect(stream);
	assertThat("detected", mimetype.match("application/json"), is(true));
}
 

/**
 * 
 * @param s mimeType as String
 * @return MimeType 
 */
private static final MimeType registerMimeType(String s) {
    try {
        return new MimeType(s);
    } catch (MimeTypeParseException e) {
        throw new RuntimeException("Can't register MIME type " + s, e);
    }
}
 

@Test(expected = ContentHandlerException.class)
public void setContent_unknown() throws ContentHandlerException, MimeTypeDetectionException, MimeTypeParseException {
	final SendGrid.Email email = new SendGrid.Email();
	final StringContent content = new StringContent(CONTENT_JSON);

	final MimeType mime = new MimeType("application/json");
	when(provider.detect(CONTENT_JSON)).thenReturn(mime);

	instance.setContent(null, email, content);
}
 

/**
 * Match content type against expected type
 */
protected void matchResponseContentType(String expectedType) {
	String fullType = getResponseContentType();
	if (fullType == null) {
		assertNull(expectedType);
	} else {
		try {
			MimeType ctype = new MimeType(fullType);
			assertTrue("Types "+fullType+" and "+expectedType+" do not match", ctype.match(expectedType));
		} catch (MimeTypeParseException e) {
			assertEquals(expectedType, fullType);
		}

	}
}
 

private static MimeType toMimetype(String original, String replaced) throws MimeTypeDetectionException {
	try {
		return new MimeType(replaced);
	} catch (MimeTypeParseException e) {
		throw new InvalidMimetypeException("Replacing mimetype " + original + " by " + replaced + " failed because " + replaced + " is not valid", e);
	}
}
 

@Override
public UrlRewriteFilterContentDescriptor addContent( String type ) {
  UrlRewriteFilterContentDescriptorImpl impl = new UrlRewriteFilterContentDescriptorImpl();
  impl.type( type );
  contentList.add( impl );
  try {
    contentMap.put( new MimeType( type ), impl );
  } catch( MimeTypeParseException e ) {
    throw new IllegalArgumentException( type, e );
  }
  return impl;
}
 

@Override
public TranslatableString satisfiesTranslatableSafely(final String mimeType) {
    try {
        new MimeType(mimeType);
    } catch (MimeTypeParseException e) {
        return TranslatableString.tr("Invalid mime type");
    }
    return null;
}
 

@Test
public void setContent_html() throws ContentHandlerException, MimeTypeDetectionException, MimeTypeParseException {
	final SendGrid.Email email = new SendGrid.Email();
	final StringContent content = new StringContent(CONTENT_HTML);

	final MimeType mime = new MimeType("text/html");
	when(provider.detect(CONTENT_HTML)).thenReturn(mime);

	instance.setContent(null, email, content);

	assertEquals("The email was not correctly updated", CONTENT_HTML, email.getHtml());
}
 

protected void assertEquals(File reference, File output, MimeType content)
		throws MimeTypeParseException, IOException {
	// Plaintext matching.
	if (content.match("text/csv")) {
		assertContentEquals(reference, output);
	}

	// RDF matching.
	else if (content.match("text/turtle")
			|| content.match("application/rdf+xml")) {
		assertRDFEquals(contentsAsString(reference),
				contentsAsString(output), content.toString(),
				content.toString());
	}
}
 

@Override
public MimeTypeProvider build() {
	try {
		List<MimeTypeProvider> providers = new ArrayList<>();
		buildTika(providers);
		buildDefault(providers);
		assertNotEmpty(providers);
		MimeTypeProvider provider = buildProvider(providers);
		return validateProvider(overrideProvider(provider));
	} catch (MimeTypeParseException e) {
		throw new BuildException("Failed to build mimetype provider", e);
	}
}
 

@Override
public MimeType getMimeType(File file) throws MimeTypeDetectionException {
	try {
		LOG.debug("Detect mime type for file {}", file);
		String contentType = Files.probeContentType(file.toPath());
		if (contentType == null) {
			LOG.debug("Detected mime type for file {} is null", file);
			throw new MimeTypeDetectionException("Can't determine mimetype for file " + file);
		}
		return new MimeType(contentType);
	} catch (MimeTypeParseException | IOException e) {
		throw new MimeTypeDetectionException("Failed to detect mimetype for " + file, e);
	}
}
 

public Source parse(CharSequence text) throws SAXException  {
    try {
        if(text instanceof Base64Data)
            return new DataSourceSource( ((Base64Data)text).getDataHandler() );
        else
            return new DataSourceSource(new ByteArrayDataSource(decodeBase64(text),
                UnmarshallingContext.getInstance().getXMIMEContentType()));
    } catch (MimeTypeParseException e) {
        UnmarshallingContext.getInstance().handleError(e);
        return null;
    }
}
 

/**
 * Initialize the provider with <code>text/plain</code> Mime Type
 */
public FixedMimeTypeProvider() {
	try {
		mimetype = new MimeType("text/plain");
	} catch (MimeTypeParseException e) {
		throw new AssertionError("This should never happen as 'text/plain' is a valid MIME type", e);
	}
}
 

@Override
public MimeType getMimeType(File file) throws MimeTypeDetectionException {
	try {
		LOG.debug("Detect mime type for file {}", file);
		String contentType = map.getContentType(file);
		LOG.debug("Detected mime type for file {}: {}", file, contentType);
		return new MimeType(contentType);
	} catch (MimeTypeParseException e) {
		throw new MimeTypeDetectionException("Failed to detect mimetype for " + file, e);
	}
}
 

@Override
public MimeType detect(String content) throws MimeTypeDetectionException {
	try {
		LOG.debug("Detect mime type from stream");
		String mimetype = tika.detect(content.getBytes());
		LOG.debug("Detect mime type from stream: {}", mimetype);
		checkMimeType(mimetype);
		return new MimeType(mimetype);
	} catch (MimeTypeParseException e) {
		throw new InvalidMimetypeException("Invalid mimetype", e);
	}
}
 

@Test
public void setContent_html() throws ContentHandlerException, MimeTypeDetectionException, MimeTypeParseException {
	final Mail email = new Mail();
	final StringContent content = new StringContent(CONTENT_HTML);

	final MimeType mime = new MimeType("text/html");
	when(provider.detect(CONTENT_HTML)).thenReturn(mime);

	instance.setContent(null, email, content);

	assertEquals("The email was not correctly updated", CONTENT_HTML, getHtml(email));
}
 

@Test
public void setContent_text() throws ContentHandlerException, MimeTypeDetectionException, MimeTypeParseException {
	final Mail email = new Mail();

	final MimeType mime = new MimeType("text/plain");
	when(provider.detect(CONTENT_TEXT)).thenReturn(mime);

	instance.setContent(null, email, content);

	assertEquals("The email was not correctly updated", CONTENT_TEXT, getText(email));
}
 

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
public boolean isMimeTypeWhitelisted(final String mimeTypeString) {
	try {
		final MimeType mimeType = new MimeType(mimeTypeString);
		return isMimeTypeWhitelisted(mimeType);
	} catch (MimeTypeParseException e) {
		return false;
	}
}