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

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

Introduction

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

Prototype

String type

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

Click Source Link

Usage

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

public static boolean isCompatibleMediaType(MediaType mediaType) {
    if (mediaType == null) {
        return false;
    }/* ww  w.j  av  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:google.registry.gcs.GcsUtils.java

/** Determines most appropriate {@link GcsFileOptions} based on filename extension. */
private static GcsFileOptions getOptions(GcsFilename filename) {
    Builder builder = new GcsFileOptions.Builder().cacheControl("no-cache");
    MediaType mediaType = EXTENSIONS.get(getLast(Splitter.on('.').split(filename.getObjectName())));
    if (mediaType != null) {
        builder = builder.mimeType(mediaType.type());
    }/* w  w w.  j  ava 2  s  .  com*/
    return builder.build();
}

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

private static Optional<GuacamoleConfiguration> buildConfigurationFromRequest(HttpServletRequest req)
        throws GuacamoleException {
    try {/*from  ww w.ja v a  2  s.co m*/
        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: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 ww.j  a  v a2  s  .  c o  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: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 {/*  ww w  .  jav  a2  s  .c o  m*/
            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:at.ac.univie.isc.asio.matcher.MimeMatcher.java

private boolean mainTypeCompatible(final MediaType actual) {
    return expected.type().equals(WILDCARD) || actual.type().equals(expected.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/*ww w .ja v  a2  s.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 {//  w w w.  j av a  2s. 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 {/*  w  ww  .  j  a va  2  s . co m*/
        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());
    }
}

From source file:de.ks.file.FileStore.java

public List<FileReference> getFilesByMimeType(MediaType mediaType) {
    assert mediaType != null;

    List<FileReference> references = PersistentWork.from(FileReference.class, (root, query, builder) -> {
        javax.persistence.criteria.Path<String> mimeType = root.get(KEY_MIMETYPE);
        if (!mediaType.type().equals("*")) {
            String pattern = mediaType.type() + "%";
            Predicate like = builder.like(mimeType, pattern);
            query.where(like);//w  ww  .j  a v  a2 s.c  o  m
        }
    }, null);

    log.info("Found {} references for mimeType {}", references.size(), mediaType.type());
    return references;
}