Java Code Examples for javax.ws.rs.core.MediaType#getType()

@Override
public Model readFrom(Class<Model> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException
{
    if (log.isTraceEnabled()) log.trace("Reading Model with HTTP headers: {} MediaType: {}", httpHeaders, mediaType);
    
    Model model = ModelFactory.createDefaultModel();

    MediaType formatType = new MediaType(mediaType.getType(), mediaType.getSubtype()); // discard charset param
    Lang lang = RDFLanguages.contentTypeToLang(formatType.toString());
    if (lang == null)
    {
        if (log.isErrorEnabled()) log.error("MediaType '{}' not supported by Jena", formatType);
        throw new NoReaderForLangException("MediaType not supported: " + formatType);
    }
    if (log.isDebugEnabled()) log.debug("RDF language used to read Model: {}", lang);
    
    return read(model, entityStream, lang, getUriInfo().getBaseUri().toString());
}
 

@Override
public void writeTo(Model model, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException
{
    if (log.isTraceEnabled()) log.trace("Writing Model with HTTP headers: {} MediaType: {}", httpHeaders, mediaType);

    MediaType formatType = new MediaType(mediaType.getType(), mediaType.getSubtype()); // discard charset param
    Lang lang = RDFLanguages.contentTypeToLang(formatType.toString());
    if (lang == null)
    {
        if (log.isErrorEnabled()) log.error("MediaType '{}' not supported by Jena", formatType);
        throw new NoWriterForLangException("MediaType not supported: " + formatType);
    }
    if (log.isDebugEnabled()) log.debug("RDF language used to read Model: {}", lang);
    
    write(model, entityStream, lang, getUriInfo().getBaseUri().toString());
}
 

public static String getKey(MediaType mediaType) {

        if (mediaType == null) {
            return MediaType.WILDCARD;
        }

        return mediaType.getType() + "/" + mediaType.getSubtype(); // key does not contain any charset
    }
 

private String reformatDigFile(String content, String mediaTypeString, String mediaTypeOverride)
{
    MediaType mediaType;
    if (Strings.isNullOrEmpty(mediaTypeOverride)) {
        if (Strings.isNullOrEmpty(mediaTypeString)) {
            throw new TaskExecutionException("Content-Type must be set in the HTTP response but not set");
        }
        mediaType = MediaType.valueOf(mediaTypeString);
    }
    else {
        mediaType = MediaType.valueOf(mediaTypeOverride);
    }

    String t = mediaType.getType() + "/" + mediaType.getSubtype();  // without ;charset= or other params
    switch (t) {
    case MediaType.APPLICATION_JSON:
        try {
            // parse as json
            Config sourceConfig = cf.fromJsonString(content);
            // reformat as yaml
            return formatYaml(sourceConfig);
        }
        catch (ConfigException ex) {
            throw new RuntimeException("Failed to parse response as JSON: " + ex.getMessage(), ex);
        }

    case "application/x-yaml":
        // use as-is; let projectLoader.loadWorkflowFileFromPath handle parse errors
        return content;

    //case MediaType.TEXT_PLAIN:
    //case MediaType.APPLICATION_OCTET_STREAM:

    default:
        throw new TaskExecutionException("Unsupported Content-Type (expected application/json or application/x-yaml): " + mediaTypeString);
    }
}
 

/**
 * Convert a media type object to a string.
 *
 * @param type MediaType object
 * @return string media type
 */
public String toString(MediaType type) {
    if (type == null) {
        throw new IllegalArgumentException("MediaType can not be null");
    }
    return type.getType() + '/' + type.getSubtype();
}
 

/**
 * Returns RDF data from a graph in the repository.
 *
 * @see RDFStreamingOutput
 * @param req JAX-RS {@link Request} object
 * @param def the "default" query parameter
 * @param graphString the "graph" query parameter
 * @return RDF data as HTTP response
 */
private Response handleGet(
		Request req,
		String def,
		String graphString) {
	// select matching MIME-Type for response based on HTTP headers
	final Variant variant = req.selectVariant(rdfResultVariants);
	final MediaType mt = variant.getMediaType();
	final String mtstr = mt.getType() + "/" + mt.getSubtype();
	final RDFFormat format = getRDFFormat(mtstr);
	StreamingOutput stream;
	RepositoryConnection conn = null;
	try {
		// return data as RDF stream
		conn = getConnection();
		if (graphString != null) {
			Resource ctx = vf.createURI(graphString);
			if (conn.size(ctx) == 0) {
				return Response.status(Response.Status.NOT_FOUND).build();
			}
			stream = new RDFStreamingOutput(conn, format, ctx);
		} else {
			stream = new RDFStreamingOutput(conn, format);
		}
	} catch (RepositoryException ex) {
		// server error
		close(conn, ex);
		throw new WebApplicationException(ex);
	}
	return Response.ok(stream).build();
}
 

static void populateResponseBody(ResponseBuilder builder, String entity, Variant variant, boolean includeEntity) {
	MediaType mediaType = variant.getMediaType();

	String charsetName=mediaType.getParameters().get(MediaType.CHARSET_PARAMETER);
	Charset charset=StandardCharsets.UTF_8;
	if(charsetName!=null && !charsetName.isEmpty() && Charset.isSupported(charsetName)) {
		charset=Charset.forName(charsetName);
	} else {
		LOGGER.error("Missing of invalid charset information {}",mediaType);
		charsetName=charset.name();
	}

	MediaType target=
		Configuration.includeCharsetInformation()?
			mediaType.withCharset(charsetName):
			new MediaType(mediaType.getType(),mediaType.getSubtype());

	byte[] bytes = entity.getBytes(charset);
	builder.
		type(target).
		header(MoreHttp.CONTENT_LENGTH_HEADER,bytes.length);

	if(variant.getLanguage()!=null) {
		builder.language(variant.getLanguage());
	}

	if(includeEntity) {
		builder.entity(new ByteArrayInputStream(bytes));
	}
}
 

@Override
public boolean intersect(MediaType requiredType, MediaType userType) {
    boolean requiredTypeWildcard = requiredType.getType().equals(MediaType.MEDIA_TYPE_WILDCARD);
    boolean requiredSubTypeWildcard = requiredType.getSubtype().contains(MediaType.MEDIA_TYPE_WILDCARD);

    String type = requiredTypeWildcard ? userType.getType() : requiredType.getType();
    String subtype = requiredSubTypeWildcard ? userType.getSubtype() : requiredType.getSubtype();

    Map<String, String> parameters = userType.getParameters();
    if (addRequiredParamsIfPossible) {
        parameters = new LinkedHashMap<>(parameters);
        for (Map.Entry<String, String> entry : requiredType.getParameters().entrySet()) {
            if (!parameters.containsKey(entry.getKey())) {
                parameters.put(entry.getKey(), entry.getValue());
            }
        }
    }
    if (addDistanceParameter) {
        int distance = 0;
        if (requiredTypeWildcard) {
            distance++;
        }
        if (requiredSubTypeWildcard) {
            distance++;
        }
        parameters.put(MEDIA_TYPE_DISTANCE_PARAM, Integer.toString(distance));
    }
    getSupportedMimeTypeList().add(new MediaType(type, subtype, parameters));
    return true;
}
 

@Override
public MediaType getNormalisedRequestMediaType(HttpServletRequest request) {
    String contentType = request.getContentType();
    if (request.getMethod().equals("POST")) {
        if (contentType == null) {
            throw new CougarValidationException(ServerFaultCode.ContentTypeNotValid, "Input content type was not specified for deserialisable response");
        }
        MediaType requestMT;
        try {
            requestMT = MediaType.valueOf(contentType);
        } catch (Exception e) {
            throw new CougarValidationException(ServerFaultCode.MediaTypeParseFailure, "Input content type cannot be parsed: " + contentType,e);
        }
        if (requestMT.isWildcardType() || requestMT.isWildcardSubtype()) {
            throw new CougarValidationException(ServerFaultCode.InvalidInputMediaType, "Input content type may not be wildcard: " + requestMT);
        }
        if (!MediaTypeUtils.isValid(allContentTypes, requestMT)) {
            throw new CougarValidationException(ServerFaultCode.ContentTypeNotValid, "Input content type is not valid: " + requestMT);
        }
        String candidateContentType = requestMT.getType() + "/" + requestMT.getSubtype();
        MediaType normalizedMediaType = validContentTypes.get(candidateContentType);
        if (normalizedMediaType == null) {
            throw new CougarValidationException(ServerFaultCode.FrameworkError, "Input content type " + contentType + " failed to find a normalized type using key " + candidateContentType);
        }
        return normalizedMediaType;
    }
    return null;
}
 

private static String mediaTypeWithoutParams(final MediaType mediaType) {
    return mediaType.getType() + "/" + mediaType.getSubtype();
}
 

private String toString(MediaType mime) {
    return mime.getType() + "/" + mime.getSubtype();
}
 

private MediaType createMediaTypeWithBoundary(MediaType mediaType, String boundary) {
    Map<String, String> parameters = newHashMap(mediaType.getParameters());
    parameters.put("boundary", boundary);
    return new MediaType(mediaType.getType(), mediaType.getSubtype(), parameters);
}
 

/**
 * Compares the {@link MediaType#getType() type} and the {@link MediaType#getSubtype() subtype} to see if they are
 * equal (case insensitive). If they are equal, then this method returns {@code true}, else returns {@code false}.
 * Unlike the {@link MediaType#equals(Object)}, this method doesn't take into account the {@link MediaType#getParameters()
 * parameters} during the equality check
 *
 * @param m1 one of the MediaType
 * @param m2 the other MediaType
 * @return
 */
private static boolean matches(final MediaType m1, final MediaType m2) {
    if (m1 == null || m2 == null) {
        return false;
    }
    if (m1.getType() == null || m1.getSubtype() == null) {
        return false;
    }
    return m1.getType().equalsIgnoreCase(m2.getType()) && m1.getSubtype().equalsIgnoreCase(m2.getSubtype());
}
 

/**
 * Convert media type to a String represents the MediaType.
 *
 * MediaType#toString requires a JAX-RS implementation.
 * To avoid that enkan requires a JAX-RS implementation, Use this method.
 *
 * @param mediaType MediaType
 * @return a String represents the MediaType
 */
public static String printMediaType(MediaType mediaType) {
    return mediaType.getType() + "/" + mediaType.getSubtype();
}