org.apache.olingo.odata2.core.exception.ODataRuntimeException Java Examples

/**
 * <p>Serializes an error message according to the OData standard.</p>
 * <p>In case an error occurs, it is logged.
 * An exception is not thrown because this method is used in exception handling.</p>
 * @param status the {@link HttpStatusCodes} associated with this error
 * @param errorCode a String that serves as a substatus to the HTTP response code
 * @param message a human-readable message describing the error
 * @param locale the {@link Locale} that should be used to format the error message
 * @param innerError the inner error for this message. If it is null or an empty String no inner error tag is shown
 * inside the response xml
 * @return an {@link ODataResponse} containing the serialized error message
 */
@Override
public ODataResponse writeErrorDocument(final HttpStatusCodes status, final String errorCode, final String message,
    final Locale locale, final String innerError) {
  CircleStreamBuffer csb = new CircleStreamBuffer();

  try {
    OutputStream outStream = csb.getOutputStream();
    XMLStreamWriter writer = XmlHelper.getXMLOutputFactory().createXMLStreamWriter(outStream, DEFAULT_CHARSET);

    XmlErrorDocumentProducer producer = new XmlErrorDocumentProducer();
    producer.writeErrorDocument(writer, errorCode, message, locale, innerError);

    writer.flush();
    csb.closeWrite();

    ODataResponseBuilder response = ODataResponse.entity(csb.getInputStream())
        .header(ODataHttpHeaders.DATASERVICEVERSION, ODataServiceVersion.V10)
        .status(status);
    return response.build();
  } catch (Exception e) {
    csb.close();
    throw new ODataRuntimeException(e);
  }
}
 

@Override
public WriteEntryCallbackResult retrieveEntryResult(final WriteEntryCallbackContext context) {
  WriteEntryCallbackResult result = new WriteEntryCallbackResult();
  try {
    if ("Employees".equals(context.getSourceEntitySet().getName())) {
      if ("ne_Room".equals(context.getNavigationProperty().getName())) {
        HashMap<String, ODataCallback> callbacks = new HashMap<String, ODataCallback>();
        for (String navPropName : context.getSourceEntitySet().getRelatedEntitySet(context.getNavigationProperty())
            .getEntityType().getNavigationPropertyNames()) {
          callbacks.put(navPropName, this);
        }
        EntityProviderWriteProperties inlineProperties =
            EntityProviderWriteProperties.serviceRoot(baseUri).callbacks(callbacks).expandSelectTree(
                context.getCurrentExpandSelectTreeNode()).build();
        result.setEntryData(dataProvider.getRoomData());
        result.setInlineProperties(inlineProperties);
      } else if ("ne_Team".equals(context.getNavigationProperty().getName())) {
        result.setEntryData(null);
      }
    }
  } catch (EdmException e) {
    throw new ODataRuntimeException("EdmException:", e);
  }
  return result;
}
 

/**
 * <p>Serializes an error message according to the OData standard.</p>
 * <p>In case an error occurs, it is logged.
 * An exception is not thrown because this method is used in exception handling.</p>
 * @param status the {@link HttpStatusCodes status code} associated with this error
 * @param errorCode a String that serves as a substatus to the HTTP response code
 * @param message a human-readable message describing the error
 * @param locale the {@link Locale} that should be used to format the error message
 * @param innerError the inner error for this message; if it is null or an empty String
 * no inner error tag is shown inside the response structure
 * @return an {@link ODataResponse} containing the serialized error message
 */
@Override
public ODataResponse writeErrorDocument(final HttpStatusCodes status, final String errorCode, final String message,
    final Locale locale, final String innerError) {
  CircleStreamBuffer buffer = new CircleStreamBuffer();

  try {
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(buffer.getOutputStream(), DEFAULT_CHARSET));
    new JsonErrorDocumentProducer().writeErrorDocument(writer, errorCode, message, locale, innerError);
    writer.flush();
    buffer.closeWrite();

    return ODataResponse.status(status)
        .entity(buffer.getInputStream())
        .header(ODataHttpHeaders.DATASERVICEVERSION, ODataServiceVersion.V10)
        .build();
  } catch (Exception e) {
    buffer.close();
    throw new ODataRuntimeException(e);
  }
}
 

/**
 * Fetch the calibrated length in case of binary data. 
 * Since after applying the charset the content length changes.
 * If the previously generated length is sent back then the batch response 
 * body is seen truncated
 * @param batchResponseBody
 * @return
 */
public int calculateLength(Object batchResponseBody) {
  if (batchResponseBody != null) {
    if (batchResponseBody instanceof String) {
      if (DEFAULT_ENCODING.equalsIgnoreCase(ISO_ENCODING)) {
        try {
          return ((String) batchResponseBody).getBytes(UTF8_ENCODING).length;
        } catch (UnsupportedEncodingException e) {
          throw new ODataRuntimeException(e);
        }
      } else {
        return getLength();
      }
    } else {
      return getLength();
    }
  }
  return getLength();
}
 

@Override
protected void service(final HttpServletRequest req, final HttpServletResponse resp) throws IOException {
  // We have to create the Service Factory here because otherwise we do not have access to the error callback
  ODataServiceFactory serviceFactory = getServiceFactory(req);
  if(serviceFactory == null) {
    throw new ODataRuntimeException("Unable to get Service Factory. Check either '" +
        ODataServiceFactory.FACTORY_LABEL + "' or '" + ODataServiceFactory.FACTORY_INSTANCE_LABEL + "' config.");
  }

  String xHttpMethod = req.getHeader("X-HTTP-Method");
  String xHttpMethodOverride = req.getHeader("X-HTTP-Method-Override");
  if (xHttpMethod != null && xHttpMethodOverride != null) {
    if (!xHttpMethod.equalsIgnoreCase(xHttpMethodOverride)) {
      ODataExceptionWrapper wrapper = new ODataExceptionWrapper(req, serviceFactory);
      createResponse(resp, wrapper.wrapInExceptionResponse(
          new ODataBadRequestException(ODataBadRequestException.AMBIGUOUS_XMETHOD)));
      return;
    }
  }

  if (req.getPathInfo() != null) {
    handle(req, resp, xHttpMethod, xHttpMethodOverride, serviceFactory);
  } else {
    handleRedirect(req, resp, serviceFactory);
  }
}
 

public static ODataServiceFactory createServiceFactoryFromContext(final Application app,
    final HttpServletRequest servletRequest,
    final ServletConfig servletConfig) {
  try {
    Class<?> factoryClass;
    if (app instanceof AbstractODataApplication) {
      factoryClass = ((AbstractODataApplication) app).getServiceFactoryClass();
    } else {
      final String factoryClassName = servletConfig.getInitParameter(ODataServiceFactory.FACTORY_LABEL);
      if (factoryClassName == null) {
        throw new ODataRuntimeException("Servlet config missing: " + ODataServiceFactory.FACTORY_LABEL);
      }

      ClassLoader cl = (ClassLoader) servletRequest.getAttribute(ODataServiceFactory.FACTORY_CLASSLOADER_LABEL);
      if (cl == null) {
        factoryClass = Class.forName(factoryClassName);
      } else {
        factoryClass = Class.forName(factoryClassName, true, cl);
      }
    }
    return (ODataServiceFactory) factoryClass.newInstance();
  } catch (Exception e) {
    throw new ODataRuntimeException("Exception during ODataServiceFactory creation occured.", e);
  }
}
 

@Override
public ODataJPAContext initializeODataJPAContext()
		throws ODataJPARuntimeException {
	ODataJPAContext oDataJPAContext = this.getODataJPAContext();
	EntityManagerFactory emf;
	try {
		emf = JpaEntityManagerFactory.getEntityManagerFactory();
		oDataJPAContext.setEntityManagerFactory(emf);
		oDataJPAContext.setPersistenceUnitName(PERSISTENCE_UNIT_NAME);
		oDataJPAContext.setJPAEdmExtension(new EspmProcessingExtension());
		oDataJPAContext.setJPAEdmMappingModel("EspmEdmMapping.xml");
		return oDataJPAContext;
	} catch (Exception e) {
		throw new ODataRuntimeException(e);
	}

}
 

public ODataExceptionWrapper(final ODataContext context, final Map<String, String> queryParameters,
    final List<String> acceptHeaderContentTypes) {
  contentType = getContentType(queryParameters, acceptHeaderContentTypes).toContentTypeString();
  messageLocale = MessageService.getSupportedLocale(getLanguages(context), DEFAULT_RESPONSE_LOCALE);
  httpRequestHeaders = context.getRequestHeaders();
  try {
    requestUri = context.getPathInfo().getRequestUri();
    errorContext.setPathInfo(context.getPathInfo());
    callback = getErrorHandlerCallbackFromContext(context);
  } catch (Exception e) {
    throw new ODataRuntimeException("Exception occurred", e);
  }
}
 

@Override
public ODataJPAContext initializeODataJPAContext() throws ODataJPARuntimeException {
	ODataJPAContext oDataJPAContext = this.getODataJPAContext();
	try {
		oDataJPAContext.setEntityManagerFactory(EntityManagerFactoryProvider.getInstance().getEntityManagerFactory());
		oDataJPAContext.setPersistenceUnitName(PERSISTENCE_UNIT_NAME);
		oDataJPAContext.setJPAEdmExtension(new BenefitsJPAEdmExtension());

		setContextInThreadLocal(oDataJPAContext.getODataContext());
		return oDataJPAContext;
	} catch (Exception e) {
		throw new ODataRuntimeException("Cannot initialize OData JPA Context", e); //$NON-NLS-1$
	}

}
 

@Override
protected ODataSingleProcessor createProcessor() throws ODataException {
  final ODataSingleProcessor processor = mock(ODataSingleProcessor.class);

  when(((ServiceDocumentProcessor) processor).readServiceDocument(any(GetServiceDocumentUriInfo.class),
      any(String.class))).thenThrow(new ODataRuntimeException("unit testing"));
  when(((MetadataProcessor) processor).readMetadata(any(GetMetadataUriInfo.class),
      any(String.class))).thenThrow(
      new ODataRuntimeApplicationException("unit testing", Locale.ROOT, HttpStatusCodes.FORBIDDEN));

  return processor;
}
 

@Test
public void testODataRuntimeException() throws Exception {
  // prepare
  String exceptionMessage = "Some odd runtime exception";
  Exception exception = new ODataRuntimeException(exceptionMessage);

  // execute
  Response response = exceptionMapper.toResponse(exception);

  // verify
  verifyResponse(response, exceptionMessage, HttpStatusCodes.INTERNAL_SERVER_ERROR);
}
 

public XmlExpandProducerTest(final StreamWriterImplType type) {
  super(type);

  try {
    inlineBaseUri = new URI("http://hubbeldubbel.com/");
  } catch (URISyntaxException e) {
    throw new ODataRuntimeException(e);
  }
}
 

protected static byte[] getBytes(final String body) {
  try {
    return body.getBytes(DEFAULT_ENCODING);
  } catch (UnsupportedEncodingException e) {
    throw new ODataRuntimeException(e);
  }
}
 

private void handleSystemQueryOptions() throws UriSyntaxException, UriNotMatchingException, EdmException {

    for (SystemQueryOption queryOption : systemQueryOptions.keySet()) {
      switch (queryOption) {
      case $format:
        handleSystemQueryOptionFormat(systemQueryOptions.get(SystemQueryOption.$format));
        break;
      case $filter:
        handleSystemQueryOptionFilter(systemQueryOptions.get(SystemQueryOption.$filter));
        break;
      case $inlinecount:
        handleSystemQueryOptionInlineCount(systemQueryOptions.get(SystemQueryOption.$inlinecount));
        break;
      case $orderby:
        handleSystemQueryOptionOrderBy(systemQueryOptions.get(SystemQueryOption.$orderby));
        break;
      case $skiptoken:
        handleSystemQueryOptionSkipToken(systemQueryOptions.get(SystemQueryOption.$skiptoken));
        break;
      case $skip:
        handleSystemQueryOptionSkip(systemQueryOptions.get(SystemQueryOption.$skip));
        break;
      case $top:
        handleSystemQueryOptionTop(systemQueryOptions.get(SystemQueryOption.$top));
        break;
      case $expand:
        handleSystemQueryOptionExpand(systemQueryOptions.get(SystemQueryOption.$expand));
        break;
      case $select:
        handleSystemQueryOptionSelect(systemQueryOptions.get(SystemQueryOption.$select));
        break;
      default:
        throw new ODataRuntimeException("Invalid System Query Option " + queryOption);
      }
    }
  }
 

@Override
public ExpandSelectTreeNodeBuilder
    customExpandedLink(final String navigationPropertyName, final ExpandSelectTreeNode expandNode) {
  if (expandNode == null) {
    throw new ODataRuntimeException("ExpandNode must not be null");
  }
  if (customExpandedNavigationProperties == null) {
    customExpandedNavigationProperties = new HashMap<String, ExpandSelectTreeNode>();
  }
  customExpandedNavigationProperties.put(navigationPropertyName, expandNode);
  return this;
}
 

/**
 * Get an instance of a ODataServiceFactory from request attribute
 * ODataServiceFactory.FACTORY_INSTANCE_LABEL
 *
 * @see ODataServiceFactory#FACTORY_INSTANCE_LABEL
 *
 * @param req http servlet request
 * @return instance of a ODataServiceFactory
 */
private ODataServiceFactory getODataServiceFactoryInstance(HttpServletRequest req) {
  Object factory = req.getAttribute(ODataServiceFactory.FACTORY_INSTANCE_LABEL);
  if(factory == null) {
    return null;
  } else if(factory instanceof ODataServiceFactory) {
    return (ODataServiceFactory) factory;
  }
  throw new ODataRuntimeException("Invalid service factory instance of type " + factory.getClass());
}
 

/**
 * Get the service factory instance which is used for creation of the
 * <code>ODataService</code> which handles the processing of the request.
 *
 * @param request the http request which is processed as an OData request
 * @return an instance of an ODataServiceFactory
 */
protected ODataServiceFactory getServiceFactory(HttpServletRequest request) {
  try {
    ODataServiceFactory factoryInstance = getODataServiceFactoryInstance(request);
    if(factoryInstance == null) {
      return createODataServiceFactory(request);
    }
    return factoryInstance;

  } catch (Exception e) {
    throw new ODataRuntimeException(e);
  }
}
 

public static EdmSimpleType getInternalEdmSimpleTypeByString(final String edmSimpleType) {
  if ("Bit".equals(edmSimpleType)) {
    return Bit.getInstance();
  } else if ("Uint7".equals(edmSimpleType)) {
    return Uint7.getInstance();
  } else {
    throw new ODataRuntimeException("Invalid internal Type " + edmSimpleType);
  }
}
 

public static EdmSimpleType getEdmSimpleType(final EdmSimpleTypeKind typeKind) {

    switch (typeKind) {
    case Binary:
      return EdmBinary.getInstance();
    case Boolean:
      return EdmBoolean.getInstance();
    case Byte:
      return EdmByte.getInstance();
    case DateTime:
      return EdmDateTime.getInstance();
    case DateTimeOffset:
      return EdmDateTimeOffset.getInstance();
    case Decimal:
      return EdmDecimal.getInstance();
    case Double:
      return EdmDouble.getInstance();
    case Guid:
      return EdmGuid.getInstance();
    case Int16:
      return EdmInt16.getInstance();
    case Int32:
      return EdmInt32.getInstance();
    case Int64:
      return EdmInt64.getInstance();
    case SByte:
      return EdmSByte.getInstance();
    case Single:
      return EdmSingle.getInstance();
    case String:
      return EdmString.getInstance();
    case Time:
      return EdmTime.getInstance();
    case Null:
      return EdmNull.getInstance();
    default:
      throw new ODataRuntimeException("Invalid Type " + typeKind);
    }
  }
 

@Override
public ODataResponse writeErrorDocument(final ODataErrorContext context) {
  try {
    return create(context.getContentType()).writeErrorDocument(context.getHttpStatus(), context.getErrorCode(),
        context.getMessage(), context.getLocale(), context.getInnerError());
  } catch (EntityProviderException e) {
    throw new ODataRuntimeException(e);
  }
}
 

private static void writeProperties(final Collection<Property> properties,
    final Map<String, String> predefinedNamespaces, final XMLStreamWriter xmlStreamWriter) throws XMLStreamException {
  for (Property property : properties) {
    xmlStreamWriter.writeStartElement(XmlMetadataConstants.EDM_PROPERTY);
    xmlStreamWriter.writeAttribute(XmlMetadataConstants.EDM_NAME, property.getName());
    if (property instanceof SimpleProperty) {
      xmlStreamWriter.writeAttribute(XmlMetadataConstants.EDM_TYPE, ((SimpleProperty) property).getType()
          .getFullQualifiedName().toString());
    } else if (property instanceof ComplexProperty) {
      xmlStreamWriter
          .writeAttribute(XmlMetadataConstants.EDM_TYPE, ((ComplexProperty) property).getType().toString());
    } else {
      throw new ODataRuntimeException();
    }

    writeFacets(xmlStreamWriter, property.getFacets());

    if (property.getMimeType() != null) {
      xmlStreamWriter.writeAttribute(Edm.PREFIX_M, Edm.NAMESPACE_M_2007_08, XmlMetadataConstants.M_MIMETYPE, property
          .getMimeType());
    }

    writeCustomizableFeedMappings(property.getCustomizableFeedMappings(), xmlStreamWriter);

    writeAnnotationAttributes(property.getAnnotationAttributes(), predefinedNamespaces, null, xmlStreamWriter);

    writeDocumentation(property.getDocumentation(), predefinedNamespaces, xmlStreamWriter);

    writeAnnotationElements(property.getAnnotationElements(), predefinedNamespaces, xmlStreamWriter);

    xmlStreamWriter.writeEndElement();
  }
}
 

@Override
protected Iterator<Product> serviceIterator ()
{
   try
   {
      User u = Security.getCurrentUser();
      final List<fr.gael.dhus.database.object.Product> products =
         olingoManager.getProducts (u, filter, orderBy, skip, top);

      List<Product> prods = new ArrayList<> ();
      Iterator<fr.gael.dhus.database.object.Product> it =
         products.iterator ();
      while (it.hasNext ())
      {
         fr.gael.dhus.database.object.Product p = it.next ();
         if (p != null)
         {
            prods.add (new Product (p));
         }
      }

      return prods.iterator ();
   }
   catch (Exception e)
   {
      throw new ODataRuntimeException (e);
   }
}
 

@Override
protected Iterator<Product> serviceIterator ()
{
   try
   {
      User u = Security.getCurrentUser();
      final List<fr.gael.dhus.database.object.Product> products =
         olingoManager.getProducts (u, collectionUUID, filter, orderBy, skip,
            top);

      List<Product> prods = new ArrayList<Product> ();
      Iterator<fr.gael.dhus.database.object.Product> it =
         products.iterator ();
      while (it.hasNext ())
      {
         fr.gael.dhus.database.object.Product p = it.next ();
         if (p != null)
         {
            prods.add (new Product (p));
         }
      }

      return prods.iterator ();
   }
   catch (Exception e)
   {
      throw new ODataRuntimeException (e);
   }
}
 

protected static Class<? extends ODataProcessor> mapUriTypeToProcessorFeature(final UriInfoImpl uriInfo) {
  Class<? extends ODataProcessor> feature;

  switch (uriInfo.getUriType()) {
  case URI0:
    feature = ServiceDocumentProcessor.class;
    break;
  case URI1:
  case URI6B:
  case URI15:
    feature = EntitySetProcessor.class;
    break;
  case URI2:
  case URI6A:
  case URI16:
    feature = EntityProcessor.class;
    break;
  case URI3:
    feature = EntityComplexPropertyProcessor.class;
    break;
  case URI4:
  case URI5:
    feature = uriInfo.isValue() ? EntitySimplePropertyValueProcessor.class : EntitySimplePropertyProcessor.class;
    break;
  case URI7A:
  case URI50A:
    feature = EntityLinkProcessor.class;
    break;
  case URI7B:
  case URI50B:
    feature = EntityLinksProcessor.class;
    break;
  case URI8:
    feature = MetadataProcessor.class;
    break;
  case URI9:
    feature = BatchProcessor.class;
    break;
  case URI10:
  case URI11:
  case URI12:
  case URI13:
    feature = FunctionImportProcessor.class;
    break;
  case URI14:
    feature = uriInfo.isValue() ? FunctionImportValueProcessor.class : FunctionImportProcessor.class;
    break;
  case URI17:
    feature = EntityMediaProcessor.class;
    break;
  default:
    throw new ODataRuntimeException("Unknown or not implemented URI type: " + uriInfo.getUriType());
  }

  return feature;
}
 

private static void validateUriMethod(final ODataHttpMethod method, final UriInfoImpl uriInfo) throws ODataException {
  switch (uriInfo.getUriType()) {
  case URI0:
  case URI8:
  case URI15:
  case URI16:
  case URI50A:
  case URI50B:
    if (method != ODataHttpMethod.GET) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    }
    break;

  case URI1:
  case URI6B:
  case URI7B:
    if (method != ODataHttpMethod.GET && method != ODataHttpMethod.POST) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    }
    break;

  case URI2:
  case URI6A:
  case URI7A:
    if (method != ODataHttpMethod.GET && method != ODataHttpMethod.PUT && method != ODataHttpMethod.DELETE
        && method != ODataHttpMethod.PATCH && method != ODataHttpMethod.MERGE) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    }
    break;

  case URI3:
    if (method != ODataHttpMethod.GET && method != ODataHttpMethod.PUT && method != ODataHttpMethod.PATCH
        && method != ODataHttpMethod.MERGE) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    }
    break;

  case URI4:
  case URI5:
    if (method != ODataHttpMethod.GET && method != ODataHttpMethod.PUT && method != ODataHttpMethod.DELETE
        && method != ODataHttpMethod.PATCH && method != ODataHttpMethod.MERGE) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    } else if (method == ODataHttpMethod.DELETE && !uriInfo.isValue()) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    }
    break;

  case URI9:
    if (method != ODataHttpMethod.POST) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    }
    break;

  case URI10:
  case URI11:
  case URI12:
  case URI13:
  case URI14:
    break;

  case URI17:
    if (method != ODataHttpMethod.GET && method != ODataHttpMethod.PUT && method != ODataHttpMethod.DELETE) {
      throw new ODataMethodNotAllowedException(ODataMethodNotAllowedException.DISPATCH);
    } else {
      if (uriInfo.getFormat() != null) {
        throw new ODataBadRequestException(ODataBadRequestException.INVALID_SYNTAX);
      }
    }
    break;

  default:
    throw new ODataRuntimeException("Unknown or not implemented URI type: " + uriInfo.getUriType());
  }
}
 

@Override
public void handleReadFeed(final ReadFeedResult context) {
  throw new ODataRuntimeException("No feed expected");
}
 

@Override
public void handleReadEntry(final ReadEntryResult context) {
  throw new ODataRuntimeException("No entry expected");
}
 

@Test(expected = ODataRuntimeException.class)
public void nullNodeInCustomExpandedProperty() throws Exception {
  EdmEntitySet roomsSet = edm.getDefaultEntityContainer().getEntitySet("Rooms");
  ExpandSelectTreeNode.entitySet(roomsSet).customExpandedLink("nr_Building", null).build();
}