Example usage for org.springframework.http MediaType isCompatibleWith

List of usage examples for org.springframework.http MediaType isCompatibleWith

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.http.*
  5. MediaType
  6. isCompatibleWith

Introduction

In this page you can find the example usage for org.springframework.http MediaType isCompatibleWith.

Prototype

public boolean isCompatibleWith(@Nullable MediaType other)

Source Link

Document

Indicate whether this MediaType is compatible with the given media type.

Usage

From source file:example.xmlbeam.XmlBeamHttpMessageConverter.java

@Override
public boolean canRead(Class<?> clazz, MediaType mediaType) {
    return clazz.isInterface() && mediaType.isCompatibleWith(MediaType.APPLICATION_XML);
}

From source file:biz.c24.io.spring.core.DataFormat.java

/**
 * Returns whether the {@link DataFormat} supports the given {@link MediaType}.
 * // www.  j  a  va  2s .c  o  m
 * @param mediaType
 * @return
 */
public boolean supports(MediaType mediaType) {

    for (MediaType type : mediaTypes) {
        if (type.isCompatibleWith(mediaType)) {
            return true;
        }
    }

    return false;
}

From source file:carldav.jackrabbit.webdav.io.DavInputContext.java

/**
 * Parses the input stream into a calendar object.
 * //  ww  w . j av  a2 s.  c  o m
 * @param allowCalendarWithMethod
 *            don't break on Calendars with METHOD property
 * @return Calendar parsed
 * @throws CosmoDavException
 *             - if something is wrong this exception is thrown.
 */
public Calendar getCalendar(boolean allowCalendarWithMethod) throws CosmoDavException {
    if (calendar != null) {
        return calendar;
    }

    if (!hasStream()) {
        return null;
    }

    if (getContentType() == null) {
        throw new BadRequestException("No media type specified");
    }

    final MediaType mediaType = MediaType.parseMediaType(getContentType());
    if (!mediaType.isCompatibleWith(TEXT_CALENDAR) && !mediaType.isCompatibleWith(TEXT_VCARD)) {
        throw new UnsupportedCalendarDataException(mediaType.toString());
    }

    try {
        Calendar c = CalendarUtils.parseCalendar(getInputStream());
        c.validate(true);

        if (CalendarUtils.hasMultipleComponentTypes(c)) {
            throw new InvalidCalendarResourceException(
                    "Calendar object contains more than one type of component");
        }
        if (!allowCalendarWithMethod && c.getProperties().getProperty(Property.METHOD) != null) {
            throw new InvalidCalendarResourceException("Calendar object contains METHOD property");
        }

        calendar = c;
    } catch (IOException e) {
        throw new CosmoDavException(e);
    } catch (ParserException e) {
        throw new InvalidCalendarDataException("Failed to parse calendar object: " + e.getMessage());
    } catch (ValidationException e) {
        throw new InvalidCalendarDataException("Invalid calendar object: " + e.getMessage());
    }

    return calendar;
}

From source file:net.sf.jsog.spring.StringJsogHttpMessageConverter.java

@Override
public boolean canRead(Class<?> clazz, MediaType mediaType) {
    if (!JSOG.class.isAssignableFrom(clazz)) {
        return false;
    }/*from  w w w .  ja  v  a 2s.c  o m*/

    for (MediaType type : supportedMediaTypes) {
        if (type == null || !type.isCompatibleWith(mediaType)) {
            return false;
        }
    }

    return true;
}

From source file:org.mitre.openid.connect.web.UserInfoEndpoint.java

/**
 * Get information about the user as specified in the accessToken included in this request
 *//*from w ww . j  av a  2s .c  o m*/
@PreAuthorize("hasRole('ROLE_USER') and #oauth2.hasScope('" + SystemScopeService.OPENID_SCOPE + "')")
@RequestMapping(method = { RequestMethod.GET, RequestMethod.POST }, produces = {
        MediaType.APPLICATION_JSON_VALUE, UserInfoJWTView.JOSE_MEDIA_TYPE_VALUE })
public String getInfo(@RequestParam(value = "claims", required = false) String claimsRequestJsonString,
        @RequestHeader(value = HttpHeaders.ACCEPT, required = false) String acceptHeader,
        OAuth2Authentication auth, Model model) {

    if (auth == null) {
        logger.error("getInfo failed; no principal. Requester is not authorized.");
        model.addAttribute(HttpCodeView.CODE, HttpStatus.FORBIDDEN);
        return HttpCodeView.VIEWNAME;
    }

    String username = auth.getName();
    UserInfo userInfo = userInfoService.getByUsernameAndClientId(username,
            auth.getOAuth2Request().getClientId());

    if (userInfo == null) {
        logger.error("getInfo failed; user not found: " + username);
        model.addAttribute(HttpCodeView.CODE, HttpStatus.NOT_FOUND);
        return HttpCodeView.VIEWNAME;
    }

    model.addAttribute(UserInfoView.SCOPE, auth.getOAuth2Request().getScope());

    model.addAttribute(UserInfoView.AUTHORIZED_CLAIMS, auth.getOAuth2Request().getExtensions().get("claims"));

    if (!Strings.isNullOrEmpty(claimsRequestJsonString)) {
        model.addAttribute(UserInfoView.REQUESTED_CLAIMS, claimsRequestJsonString);
    }

    model.addAttribute(UserInfoView.USER_INFO, userInfo);

    // content negotiation

    // start off by seeing if the client has registered for a signed/encrypted JWT from here
    ClientDetailsEntity client = clientService.loadClientByClientId(auth.getOAuth2Request().getClientId());
    model.addAttribute(UserInfoJWTView.CLIENT, client);

    List<MediaType> mediaTypes = MediaType.parseMediaTypes(acceptHeader);
    MediaType.sortBySpecificityAndQuality(mediaTypes);

    if (client.getUserInfoSignedResponseAlg() != null || client.getUserInfoEncryptedResponseAlg() != null
            || client.getUserInfoEncryptedResponseEnc() != null) {
        // client has a preference, see if they ask for plain JSON specifically on this request
        for (MediaType m : mediaTypes) {
            if (!m.isWildcardType() && m.isCompatibleWith(UserInfoJWTView.JOSE_MEDIA_TYPE)) {
                return UserInfoJWTView.VIEWNAME;
            } else if (!m.isWildcardType() && m.isCompatibleWith(MediaType.APPLICATION_JSON)) {
                return UserInfoView.VIEWNAME;
            }
        }

        // otherwise return JWT
        return UserInfoJWTView.VIEWNAME;
    } else {
        // client has no preference, see if they asked for JWT specifically on this request
        for (MediaType m : mediaTypes) {
            if (!m.isWildcardType() && m.isCompatibleWith(MediaType.APPLICATION_JSON)) {
                return UserInfoView.VIEWNAME;
            } else if (!m.isWildcardType() && m.isCompatibleWith(UserInfoJWTView.JOSE_MEDIA_TYPE)) {
                return UserInfoJWTView.VIEWNAME;
            }
        }

        // otherwise return JSON
        return UserInfoView.VIEWNAME;
    }

}

From source file:org.craftercms.commons.rest.HttpMessageConvertingResponseWriter.java

public <T> void writeWithMessageConverters(T returnValue, HttpServletRequest request,
        HttpServletResponse response) throws IOException, HttpMediaTypeNotAcceptableException {
    Class<?> returnValueClass = returnValue.getClass();
    List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(request);
    List<MediaType> producibleMediaTypes = getProducibleMediaTypes(returnValueClass);

    Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
    for (MediaType r : requestedMediaTypes) {
        for (MediaType p : producibleMediaTypes) {
            if (r.isCompatibleWith(p)) {
                compatibleMediaTypes.add(getMostSpecificMediaType(r, p));
            }/*from  w w w.j av  a 2s.com*/
        }
    }
    if (compatibleMediaTypes.isEmpty()) {
        throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
    }

    List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
    MediaType.sortBySpecificityAndQuality(mediaTypes);

    MediaType selectedMediaType = null;
    for (MediaType mediaType : mediaTypes) {
        if (mediaType.isConcrete()) {
            selectedMediaType = mediaType;
            break;
        } else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
            selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
            break;
        }
    }

    if (selectedMediaType != null) {
        selectedMediaType = selectedMediaType.removeQualityValue();
        for (HttpMessageConverter<?> messageConverter : messageConverters) {
            if (messageConverter.canWrite(returnValueClass, selectedMediaType)) {
                ((HttpMessageConverter<T>) messageConverter).write(returnValue, selectedMediaType,
                        new ServletServerHttpResponse(response));

                logger.debug(LOG_KEY_WRITTEN_WITH_MESSAGE_CONVERTER, returnValue, selectedMediaType,
                        messageConverter);

                return;
            }
        }
    }

    throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
}

From source file:com.asual.summer.core.spring.ViewResolverConfiguration.java

public AbstractView handleViews(Collection<AbstractView> views, NativeWebRequest request) {
    List<MediaType> requestedMediaTypes;
    try {//from w  w w.j a va  2 s .c o m
        requestedMediaTypes = contentNegotiationManager.resolveMediaTypes(request);
        for (MediaType requestedMediaType : requestedMediaTypes) {
            for (AbstractView view : views) {
                MediaType producableMediaType = MediaType.parseMediaType(view.getContentType());
                if (requestedMediaType.isCompatibleWith(producableMediaType)
                        && !requestedMediaType.isWildcardType() && requestedMediaType.getQualityValue() > 0.9) {
                    return view;
                }
            }

        }
    } catch (HttpMediaTypeNotAcceptableException e) {
        logger.debug(e.getMessage(), e);
    }
    return null;
}

From source file:com.onedrive.api.internal.MultipartRelatedHttpMessageConverter.java

public boolean canWrite(Class<?> clazz, MediaType mediaType) {
    if (!MultiValueMap.class.isAssignableFrom(clazz)) {
        return false;
    }/*  w w  w.  j  a va  2s .  c  o m*/
    if (mediaType == null || MediaType.ALL.equals(mediaType)) {
        return true;
    }
    for (MediaType supportedMediaType : getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        }
    }
    return false;
}

From source file:edu.mayo.trilliumbridge.webapp.TransformerController.java

protected void doTransform(HttpServletRequest request, HttpServletResponse response, String acceptHeader,
        String formatOverride, Transformer transformer) throws IOException {

    // default to XML if no Accept Header (it should at least be */*, but just in case).
    if (StringUtils.isBlank(acceptHeader)) {
        acceptHeader = MediaType.APPLICATION_ATOM_XML_VALUE;
    }/*from www  .  j a  v a 2s  .  c om*/

    TrilliumBridgeTransformer.Format responseFormat = null;

    if (StringUtils.isNotBlank(formatOverride)) {
        responseFormat = TrilliumBridgeTransformer.Format.valueOf(formatOverride);
    } else {
        String[] accepts = StringUtils.split(acceptHeader, ',');

        for (String accept : accepts) {
            MediaType askedForType = MediaType.parseMediaType(accept);
            if (askedForType.isCompatibleWith(MediaType.TEXT_XML)
                    || askedForType.isCompatibleWith(MediaType.APPLICATION_XML)) {
                responseFormat = TrilliumBridgeTransformer.Format.XML;
            } else if (askedForType.isCompatibleWith(MediaType.TEXT_HTML)
                    || askedForType.isCompatibleWith(MediaType.APPLICATION_XHTML_XML)) {
                responseFormat = TrilliumBridgeTransformer.Format.HTML;
            } else if (askedForType.getType().equals("application")
                    && askedForType.getSubtype().equals("pdf")) {
                responseFormat = TrilliumBridgeTransformer.Format.PDF;
            }

            if (responseFormat != null) {
                break;
            }
        }
    }

    if (responseFormat == null) {
        throw new UserInputException("Cannot return type: " + acceptHeader, HttpStatus.NOT_ACCEPTABLE);
    }

    String contentType;
    switch (responseFormat) {
    case XML:
        contentType = MediaType.APPLICATION_XML_VALUE;
        break;
    case HTML:
        contentType = MediaType.TEXT_HTML_VALUE.toString();
        break;
    case PDF:
        contentType = "application/pdf";
        break;
    default:
        throw new IllegalStateException("Illegal Response Format");
    }

    InputStream inputStream;
    if (request instanceof MultipartHttpServletRequest) {
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        MultipartFile multipartFile = multipartRequest.getFile(INPUT_FILE_NAME);
        inputStream = multipartFile.getInputStream();
    } else {
        inputStream = request.getInputStream();
    }

    inputStream = this.checkForUtf8BOMAndDiscardIfAny(this.checkStreamIsNotEmpty(inputStream));

    // create a buffer so we don't use the servlet's output stream unless
    // we get a successful transform, because if we do use it,
    // we can't use the error view anymore.
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    transformer.transform(inputStream, baos, responseFormat);

    try {
        response.setContentType(contentType);
        response.getOutputStream().write(baos.toByteArray());
    } finally {
        IOUtils.closeQuietly(baos);
    }

}

From source file:edu.mayo.qdm.webapp.rest.controller.TranslatorController.java

/**
 * Checks if is html request./*from  w w  w  .j  a  v  a 2s  . co  m*/
 *
 * @param request the request
 * @return true, if is html request
 */
protected boolean isHtmlRequest(HttpServletRequest request) {
    String acceptHeader = request.getHeader("Accept");

    List<MediaType> types;

    if (StringUtils.isBlank(acceptHeader)) {
        types = Arrays.asList(DEFAULT_ACCEPT_HEADER);
    } else {
        types = MediaType.parseMediaTypes(acceptHeader);
    }

    MediaType.sortByQualityValue(types);

    MediaType type = types.get(0);

    return type.isCompatibleWith(MediaType.TEXT_HTML);
}