odata2-lib/odata-core/src/main/java/org/apache/olingo/odata2/core/ContentNegotiator.java

/*******************************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 ******************************************************************************/
package org.apache.olingo.odata2.core;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.olingo.odata2.api.exception.ODataBadRequestException;
import org.apache.olingo.odata2.api.exception.ODataException;
import org.apache.olingo.odata2.api.exception.ODataNotAcceptableException;
import org.apache.olingo.odata2.api.processor.ODataRequest;
import org.apache.olingo.odata2.core.commons.ContentType;
import org.apache.olingo.odata2.core.uri.UriInfoImpl;
import org.apache.olingo.odata2.core.uri.UriType;

/**
 * Handles content negotiation with handling of OData special cases.
 */
public class ContentNegotiator {
  private static final String URI_INFO_FORMAT_JSON = "json";
  private static final String URI_INFO_FORMAT_ATOM = "atom";
  private static final String URI_INFO_FORMAT_XML = "xml";
  static final String DEFAULT_CHARSET = "utf-8";

  /**
   * Do the content negotiation for <code>accept header value</code> based on
   * requested content type (in HTTP accept header from {@link ODataRequest})
   * in combination with uri information from {@link org.apache.olingo.odata2.api.uri.UriInfo} and from given supported
   * content types (via
   * <code>supportedContentTypes</code>).
   * 
   * @param request specific request
   * @param uriInfo specific uri information
   * @param supportedContentTypes list of supported content types
   * @return best fitting content type or <code>NULL</code> if content type is not set and for given
   * {@link org.apache.olingo.odata2.api.uri.UriInfo} is
   * ignored
   * @throws ODataException if no supported content type was found
   * @throws IllegalArgumentException if one of the input parameter is <code>NULL</code>
   */
  public ContentType doContentNegotiation(final ODataRequest odataRequest, final UriInfoImpl uriInfo,
      final List<String> supportedContentTypes) throws ODataException {
    validateNotNull(odataRequest, uriInfo, supportedContentTypes);

    if (uriInfo.isCount()) {
      return ContentType.TEXT_PLAIN_CS_UTF_8;
    } else if (uriInfo.isValue()) {
      if (uriInfo.getUriType() == UriType.URI5 || uriInfo.getUriType() == UriType.URI4) {
        return ContentType.TEXT_PLAIN_CS_UTF_8;
      }
      return doContentNegotiationForAcceptHeader(Arrays.asList("*/*"), ContentType.create(supportedContentTypes));
    }

    if (uriInfo.getFormat() == null) {
      return doContentNegotiationForAcceptHeader(odataRequest.getAcceptHeaders(), ContentType
          .create(supportedContentTypes));
    } else {
      return doContentNegotiationForFormat(uriInfo, ContentType.createAsCustom(supportedContentTypes));
    }
  }

  private void validateNotNull(final ODataRequest odataRequest, final UriInfoImpl uriInfo,
      final List<String> supportedContentTypes) {
    if (uriInfo == null) {
      throw new IllegalArgumentException("Parameter uriInfo MUST NOT be null.");
    }
    if (odataRequest == null) {
      throw new IllegalArgumentException("Parameter odataRequest MUST NOT be null.");
    }
    if (supportedContentTypes == null) {
      throw new IllegalArgumentException("Parameter supportedContentTypes MUST NOT be null.");
    }
  }

  private ContentType doContentNegotiationForFormat(final UriInfoImpl uriInfo,
      final List<ContentType> supportedContentTypes) throws ODataException {
    validateFormatQuery(uriInfo);
    ContentType formatContentType = mapFormat(uriInfo);
    formatContentType = ensureCharset(formatContentType);

    for (final ContentType contentType : supportedContentTypes) {
      if (contentType.equals(formatContentType)) {
        return formatContentType;
      }
    }

    throw new ODataNotAcceptableException(ODataNotAcceptableException.NOT_SUPPORTED_CONTENT_TYPE.addContent(uriInfo
        .getFormat()));
  }

  /**
   * Validates that <code>dollar format query/syntax</code> is correct for further processing.
   * If some validation error occurs an exception is thrown.
   * 
   * @param uriInfo
   * @throws ODataBadRequestException
   */
  private void validateFormatQuery(final UriInfoImpl uriInfo) throws ODataBadRequestException {
    if (uriInfo.isValue()) {
      throw new ODataBadRequestException(ODataBadRequestException.INVALID_SYNTAX);
    }
  }

  private ContentType mapFormat(final UriInfoImpl uriInfo) {
    final String format = uriInfo.getFormat();
    if (URI_INFO_FORMAT_XML.equals(format)) {
      return ContentType.APPLICATION_XML;
    } else if (URI_INFO_FORMAT_ATOM.equals(format)) {
      if (uriInfo.getUriType() == UriType.URI0) {
        // special handling for serviceDocument uris (UriType.URI0)
        return ContentType.APPLICATION_ATOM_SVC;
      } else if (uriInfo.getUriType() == UriType.URI1) {
        return ContentType.APPLICATION_ATOM_XML_FEED;
      } else if (uriInfo.getUriType() == UriType.URI2 || uriInfo.getUriType() == UriType.URI10) {
        return ContentType.APPLICATION_ATOM_XML_ENTRY;
      }
    } else if (URI_INFO_FORMAT_JSON.equals(format)) {
      return ContentType.APPLICATION_JSON;
    }

    return ContentType.createAsCustom(format);
  }

  private ContentType doContentNegotiationForAcceptHeader(final List<String> acceptHeaderContentTypes,
      final List<ContentType> supportedContentTypes) throws ODataException {
    return contentNegotiation(extractAcceptHeaders(acceptHeaderContentTypes), supportedContentTypes);
  }

  private List<ContentType> extractAcceptHeaders(final List<String> acceptHeaderValues)
      throws ODataBadRequestException {
    final List<ContentType> mediaTypes = new ArrayList<ContentType>();
    if (acceptHeaderValues != null) {
      for (final String mediaType : acceptHeaderValues) {
        try {
          mediaTypes.add(ContentType.create(mediaType.toString()));
        } catch (IllegalArgumentException e) {
          throw new ODataBadRequestException(ODataBadRequestException.INVALID_HEADER.addContent("Accept")
              .addContent(mediaType.toString()), e);
        }
      }
    }

    return mediaTypes;
  }

  ContentType contentNegotiation(final List<ContentType> acceptedContentTypes,
      final List<ContentType> supportedContentTypes) throws ODataException {
    final Set<ContentType> setSupported = new HashSet<ContentType>(supportedContentTypes);

    if (acceptedContentTypes.isEmpty()) {
      if (!setSupported.isEmpty()) {
        return supportedContentTypes.get(0);
      }
    } else {
      for (ContentType contentType : acceptedContentTypes) {
        contentType = ensureCharset(contentType);
        final ContentType match = contentType.match(supportedContentTypes);
        if (match != null) {
          return match;
        }
      }
    }

    throw new ODataNotAcceptableException(ODataNotAcceptableException.NOT_SUPPORTED_ACCEPT_HEADER
        .addContent(acceptedContentTypes.toString()));
  }

  private ContentType ensureCharset(final ContentType contentType) {
    if (ContentType.APPLICATION_ATOM_XML.isCompatible(contentType)
        || ContentType.APPLICATION_ATOM_SVC.isCompatible(contentType)
        || ContentType.APPLICATION_XML.isCompatible(contentType)) {
      return contentType.receiveWithCharsetParameter(DEFAULT_CHARSET);
    }
    return contentType;
  }
}