Example usage for com.google.common.net MediaType subtype

List of usage examples for com.google.common.net MediaType subtype

Introduction

In this page you can find the example usage for com.google.common.net MediaType subtype.

Prototype

String subtype

To view the source code for com.google.common.net MediaType subtype.

Click Source Link

Usage

From source file:co.freeside.betamax.io.ContentTypes.java

public static boolean isTextContentType(String contentType) {
    if (contentType == null) {
        return false;
    }/* w  ww . j a v  a  2  s  .  c om*/
    MediaType mediaType = MediaType.parse(contentType);
    if (mediaType.is(ANY_TEXT_TYPE) || mediaType.is(FORM_DATA)) {
        return true;
    }
    if (mediaType.is(ANY_APPLICATION_TYPE)
            && TEXT_CONTENT_TYPE_PATTERN.matcher(mediaType.subtype()).matches()) {
        return true;
    }
    return false;
}

From source file:jp.opencollector.guacamole.auth.delegated.DelegatedAuthenticationProvider.java

private static Optional<GuacamoleConfiguration> buildConfigurationFromRequest(HttpServletRequest req)
        throws GuacamoleException {
    try {/*from  w  w  w .  ja v  a 2 s .  c om*/
        if (req.getClass().getName().equals("org.glyptodon.guacamole.net.basic.rest.APIRequest")) {
            final GuacamoleConfiguration config = new GuacamoleConfiguration();
            final String protocol = req.getParameter("protocol");
            if (protocol == null)
                throw new GuacamoleException("required parameter \"protocol\" is missing");
            config.setProtocol(protocol);
            for (Map.Entry<String, String[]> param : req.getParameterMap().entrySet()) {
                String[] values = param.getValue();
                if (values.length > 0)
                    config.setParameter(param.getKey(), values[0]);
            }
            return Optional.of(config);
        } else {
            final ServletInputStream is = req.getInputStream();
            if (!is.isReady()) {
                MediaType contentType = MediaType.parse(req.getContentType());
                boolean invalidContentType = true;
                if (contentType.type().equals("application")) {
                    if (contentType.subtype().equals("json")) {
                        invalidContentType = false;
                    } else if (contentType.subtype().equals("x-www-form-urlencoded")
                            && req.getParameter("token") != null) {
                        return Optional.<GuacamoleConfiguration>absent();
                    }
                }
                if (invalidContentType)
                    throw new GuacamoleException(String.format("expecting application/json, got %s",
                            contentType.withoutParameters()));
                final GuacamoleConfiguration config = new GuacamoleConfiguration();
                try {
                    final ObjectMapper mapper = new ObjectMapper();
                    JsonNode root = (JsonNode) mapper.readTree(
                            createJsonParser(req.getInputStream(), contentType.charset().or(UTF_8), mapper));
                    {
                        final JsonNode protocol = root.get("protocol");
                        if (protocol == null)
                            throw new GuacamoleException("required parameter \"protocol\" is missing");
                        final JsonNode parameters = root.get("parameters");
                        if (parameters == null)
                            throw new GuacamoleException("required parameter \"parameters\" is missing");
                        config.setProtocol(protocol.asText());
                        {
                            for (Iterator<Entry<String, JsonNode>> i = parameters.fields(); i.hasNext();) {
                                Entry<String, JsonNode> member = i.next();
                                config.setParameter(member.getKey(), member.getValue().asText());
                            }
                        }
                    }
                } catch (ClassCastException e) {
                    throw new GuacamoleException("error occurred during parsing configuration", e);
                }
                return Optional.of(config);
            } else {
                return Optional.<GuacamoleConfiguration>absent();
            }
        }
    } catch (IOException e) {
        throw new GuacamoleException("error occurred during retrieving configuration from the request body", e);
    }
}

From source file:io.katharsis.invoker.internal.JsonApiMediaType.java

public static boolean isCompatibleMediaType(MediaType mediaType) {
    if (mediaType == null) {
        return false;
    }/*from w  ww .j  a  v a  2 s . c  o m*/

    if (WILDCARD.equals(mediaType.type())) {
        return true;
    }

    if (MediaType.ANY_APPLICATION_TYPE.type().equalsIgnoreCase(mediaType.type())) {
        log.debug("application mediaType : {}", mediaType);
        if (WILDCARD.equals(mediaType.subtype())) {
            return true;
        }

        if (APPLICATION_JSON_API_TYPE.subtype().equalsIgnoreCase(mediaType.subtype())) {
            log.debug("application mediaType having json api subtype : {}", mediaType);
            return true;
        }
    }

    return false;
}

From source file:org.mule.module.http.internal.listener.HttpRequestToMuleEvent.java

public static MuleEvent transform(final HttpRequestContext requestContext, final MuleContext muleContext,
        final FlowConstruct flowConstruct, Boolean parseRequest, ListenerPath listenerPath)
        throws HttpRequestParsingException {
    final HttpRequest request = requestContext.getRequest();
    final Collection<String> headerNames = request.getHeaderNames();
    Map<String, Object> inboundProperties = new HashMap<>();
    Map<String, Object> outboundProperties = new HashMap<>();
    for (String headerName : headerNames) {
        final Collection<String> values = request.getHeaderValues(headerName);
        if (values.size() == 1) {
            inboundProperties.put(headerName, values.iterator().next());
        } else {/* w w  w. j  a v  a 2s.com*/
            inboundProperties.put(headerName, values);
        }
    }

    new HttpMessagePropertiesResolver().setMethod(request.getMethod())
            .setProtocol(request.getProtocol().asString()).setUri(request.getUri())
            .setListenerPath(listenerPath).setRemoteHostAddress(resolveRemoteHostAddress(requestContext))
            .setScheme(requestContext.getScheme())
            .setClientCertificate(requestContext.getClientConnection().getClientCertificate())
            .addPropertiesTo(inboundProperties);

    final Map<String, DataHandler> inboundAttachments = new HashMap<>();
    Object payload = NullPayload.getInstance();
    if (parseRequest) {
        final HttpEntity entity = request.getEntity();
        if (entity != null && !(entity instanceof EmptyHttpEntity)) {
            if (entity instanceof MultipartHttpEntity) {
                inboundAttachments.putAll(createDataHandlerFrom(((MultipartHttpEntity) entity).getParts()));
            } else {
                final String contentTypeValue = request.getHeaderValue(HttpHeaders.Names.CONTENT_TYPE);
                if (contentTypeValue != null) {
                    final MediaType mediaType = MediaType.parse(contentTypeValue);
                    String encoding = mediaType.charset().isPresent() ? mediaType.charset().get().name()
                            : Charset.defaultCharset().name();
                    outboundProperties.put(MULE_ENCODING_PROPERTY, encoding);
                    if ((mediaType.type() + "/" + mediaType.subtype())
                            .equals(HttpHeaders.Values.APPLICATION_X_WWW_FORM_URLENCODED)) {
                        try {
                            payload = decodeUrlEncodedBody(
                                    IOUtils.toString(((InputStreamHttpEntity) entity).getInputStream()),
                                    encoding);
                        } catch (IllegalArgumentException e) {
                            throw new HttpRequestParsingException("Cannot decode x-www-form-urlencoded payload",
                                    e);
                        }
                    } else if (entity instanceof InputStreamHttpEntity) {
                        payload = ((InputStreamHttpEntity) entity).getInputStream();
                    }
                } else if (entity instanceof InputStreamHttpEntity) {
                    payload = ((InputStreamHttpEntity) entity).getInputStream();
                }
            }
        }
    } else {
        final InputStreamHttpEntity inputStreamEntity = request.getInputStreamEntity();
        if (inputStreamEntity != null) {
            payload = inputStreamEntity.getInputStream();
        }
    }

    final DefaultMuleMessage defaultMuleMessage = new DefaultMuleMessage(payload, inboundProperties,
            outboundProperties, inboundAttachments, muleContext);
    return new DefaultMuleEvent(defaultMuleMessage, resolveUri(requestContext), REQUEST_RESPONSE, flowConstruct,
            new DefaultMuleSession());
}

From source file:org.mule.module.apikit.RestContentTypeParser.java

/**
 * Find the best match for a given mimeType against a list of media_ranges
 * that have already been parsed by MimeParse.parseMediaRange(). Returns a
 * tuple of the fitness value and the value of the 'q' quality parameter of
 * the best match, or (-1, 0) if no match was found. Just as for
 * quality_parsed(), 'parsed_ranges' must be a list of parsed media ranges.
 *
 * @param target/*w  w  w.j ava2s  .  co  m*/
 * @param parsedRanges
 * @deprecated used by apikit1 only
 */
protected static FitnessAndQuality fitnessAndQualityParsed(MediaType target, List<MediaType> parsedRanges) {
    int bestFitness = -1;
    float bestFitQ = 0;

    for (MediaType range : parsedRanges) {
        if ((target.type().equals(range.type()) || range.type().equals("*") || target.type().equals("*"))
                && (target.subtype().equals(range.subtype()) || range.subtype().equals("*")
                        || target.subtype().equals("*"))) {
            for (String k : target.parameters().keySet()) {
                int paramMatches = 0;
                if (!k.equals("q") && range.parameters().containsKey(k)
                        && target.parameters().get(k).equals(range.parameters().get(k))) {
                    paramMatches++;
                }
                int fitness = (range.type().equals(target.type())) ? 100 : 0;
                fitness += (range.subtype().equals(target.subtype())) ? 10 : 0;
                fitness += paramMatches;
                if (fitness > bestFitness) {
                    bestFitness = fitness;

                    if (range.type().equals("*") && range.subtype().equals("*")) {
                        bestFitQ = NumberUtils.toFloat(target.parameters().get("q").get(0), 0);
                    } else {
                        bestFitQ = NumberUtils.toFloat(range.parameters().get("q").get(0), 0);
                    }
                }
            }
        }
    }
    return new FitnessAndQuality(bestFitness, bestFitQ);
}

From source file:at.ac.univie.isc.asio.matcher.MimeMatcher.java

private boolean subTypeCompatible(final MediaType actual) {
    return (expected.subtype().equals(WILDCARD) || actual.subtype().equals(expected.subtype())
            || actual.subtype().endsWith("+" + expected.subtype()));
}

From source file:com.buildria.mocking.builder.action.BodyAction.java

private SubType getSubType(MediaType mediaType) {
    if ("xml".equalsIgnoreCase(mediaType.subtype())) {
        return SubType.XML;
    } else if ("json".equalsIgnoreCase(mediaType.subtype())) {
        return SubType.JSON;
    } else {//from   w w  w  .  j a v  a2  s  .  co  m
        throw new MockingException("Not supported Content-Type.");
    }
}

From source file:org.mule.module.apikit.transform.ApikitResponseTransformer.java

private Collection<String> transformAcceptedTypes(String acceptedHeader) {
    List<MediaType> acceptedMediaTypes = RestContentTypeParser.parseMediaTypes(acceptedHeader);

    return Collections2.transform(acceptedMediaTypes, new Function<MediaType, String>() {
        @Override// w  ww . j a v  a  2s .c  om
        public String apply(MediaType mediaType) {
            return mediaType.type() + "/" + mediaType.subtype();
        }
    });
}

From source file:io.soabase.web.assets.InternalAssetServlet.java

private void serveTemplate(HttpServletRequest request, HttpServletResponse response, String path) {
    try {//from  w w  w  .  j a  va2  s  .  c o m
        Template template = getTemplate(path);
        String content = template
                .apply(contextCache.getContext(request, requestLanguage.getLanguageCode(request)));
        String mimeTypeOfExtension = request.getServletContext().getMimeType(request.getRequestURI());
        MediaType mediaType = MediaType.parse(mimeTypeOfExtension);
        response.setContentType(mediaType.type() + '/' + mediaType.subtype());
        if (mediaType.type().equals("text") || mediaType.subtype().equals("javascript")) {
            response.setCharacterEncoding(Charsets.UTF_8.name());
        }
        response.setContentLength(content.length());
        CharStreams.copy(new StringReader(content), response.getWriter());
    } catch (Exception e) {
        log.error("Could not serve template: " + path, e);
    }
}

From source file:net.morimekta.providence.server.ProvidenceServlet.java

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PProcessor processor = processorProvider.processorForRequest(req);
    try {//from ww  w  .j a  v a 2 s.  c om
        Serializer requestSerializer = serializerProvider.getDefault();
        if (req.getContentType() != null) {
            requestSerializer = serializerProvider.getSerializer(req.getContentType());

            if (requestSerializer == null) {
                resp.sendError(HttpServletResponse.SC_BAD_REQUEST,
                        "Unknown content-type: " + req.getContentType());
                return;
            }
        }

        Serializer responseSerializer = requestSerializer;
        String acceptHeader = resp.getHeader("Accept");
        if (acceptHeader != null) {
            String[] entries = acceptHeader.split("[,]");
            for (String entry : entries) {
                if (entry.trim().isEmpty()) {
                    continue;
                }

                try {
                    MediaType mediaType = MediaType.parse(entry.trim());
                    Serializer tmp = serializerProvider
                            .getSerializer(mediaType.type() + "/" + mediaType.subtype());
                    if (tmp != null) {
                        responseSerializer = tmp;
                        break;
                    }
                } catch (IllegalArgumentException ignore) {
                    // Ignore. Bad header input is pretty common.
                }
            }
            if (responseSerializer == null) {
                resp.sendError(HttpServletResponse.SC_BAD_REQUEST,
                        "No supported accept media-type: " + acceptHeader);
                return;
            }
        }

        MessageReader reader = new IOMessageReader(req.getInputStream(), requestSerializer);

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        MessageWriter writer = new IOMessageWriter(baos, responseSerializer);

        // Create a new processor handler instance for each request, as
        // they may be request context dependent. E.g. depends on
        // information in header, servlet context etc.
        new DefaultProcessorHandler(processor).process(reader, writer);

        resp.setStatus(HttpServletResponse.SC_OK);
        resp.setContentType(responseSerializer.mimeType());
        resp.setContentLength(baos.size());
        resp.getOutputStream().write(baos.toByteArray());
    } catch (Exception e) {
        LOGGER.error("Exception in service call for " + processor.getDescriptor().getQualifiedName(), e);
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Internal error: " + e.getMessage());
    }
}