Java tutorial
package com.temenos.interaction.media.odata.xml.atom; /* * #%L * interaction-media-odata-xml * %% * Copyright (C) 2012 - 2013 Temenos Holdings N.V. * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * #L% */ import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.PushbackInputStream; import java.io.Reader; import java.lang.annotation.Annotation; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.regex.Pattern; import javax.ws.rs.Consumes; import javax.ws.rs.Produces; import javax.ws.rs.WebApplicationException; import javax.ws.rs.core.Context; import javax.ws.rs.core.HttpHeaders; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MultivaluedMap; import javax.ws.rs.core.Request; import javax.ws.rs.core.Response; import javax.ws.rs.core.Response.Status; import javax.ws.rs.core.UriInfo; import javax.ws.rs.ext.MessageBodyReader; import javax.ws.rs.ext.MessageBodyWriter; import javax.ws.rs.ext.Provider; import org.apache.commons.io.IOUtils; import org.odata4j.core.OEntities; import org.odata4j.core.OEntity; import org.odata4j.core.OEntityKey; import org.odata4j.core.OLink; import org.odata4j.core.OLinks; import org.odata4j.edm.EdmDataServices; import org.odata4j.edm.EdmEntitySet; import org.odata4j.edm.EdmEntityType; import org.odata4j.exceptions.NotFoundException; import org.odata4j.format.Entry; import org.odata4j.format.xml.AtomEntryFormatParserExt; import org.odata4j.internal.InternalUtil; import org.odata4j.producer.Responses; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.temenos.interaction.core.ExtendedMediaTypes; import com.temenos.interaction.core.UriInfoImpl; import com.temenos.interaction.core.command.InteractionContext; import com.temenos.interaction.core.entity.Entity; import com.temenos.interaction.core.entity.EntityProperties; import com.temenos.interaction.core.entity.EntityProperty; import com.temenos.interaction.core.entity.Metadata; import com.temenos.interaction.core.hypermedia.BeanTransformer; import com.temenos.interaction.core.hypermedia.CollectionResourceState; import com.temenos.interaction.core.hypermedia.DefaultResourceStateProvider; import com.temenos.interaction.core.hypermedia.HypermediaTemplateHelper; import com.temenos.interaction.core.hypermedia.Link; import com.temenos.interaction.core.hypermedia.MethodNotAllowedException; import com.temenos.interaction.core.hypermedia.ResourceState; import com.temenos.interaction.core.hypermedia.ResourceStateMachine; import com.temenos.interaction.core.hypermedia.ResourceStateProvider; import com.temenos.interaction.core.hypermedia.Transformer; import com.temenos.interaction.core.hypermedia.Transition; import com.temenos.interaction.core.resource.CollectionResource; import com.temenos.interaction.core.resource.EntityResource; import com.temenos.interaction.core.resource.RESTResource; import com.temenos.interaction.core.resource.ResourceTypeHelper; import com.temenos.interaction.core.rim.URLHelper; import com.temenos.interaction.core.web.RequestContext; import com.temenos.interaction.odataext.entity.MetadataOData4j; @Provider @Consumes({ MediaType.APPLICATION_ATOM_XML }) @Produces({ ExtendedMediaTypes.APPLICATION_ATOMSVC_XML, MediaType.APPLICATION_ATOM_XML, MediaType.APPLICATION_XML }) public class AtomXMLProvider implements MessageBodyReader<RESTResource>, MessageBodyWriter<RESTResource> { private static final String UTF_8 = "UTF-8"; private static final Logger LOGGER = LoggerFactory.getLogger(AtomXMLProvider.class); private static final Pattern STRING_KEY_RESOURCE_PATTERN = Pattern.compile("(\\('.*'\\))"); @Context private UriInfo uriInfo; @Context private Request requestContext; private AtomEntryFormatWriter entryWriter; private AtomFeedFormatWriter feedWriter; private AtomEntityEntryFormatWriter entityEntryWriter; private final MetadataOData4j metadataOData4j; private final Metadata metadata; private final ResourceState serviceDocument; private final Transformer transformer; private final LinkInterceptor linkInterceptor = new ODataLinkInterceptor(this); private ResourceStateProvider resourceStateProvider; /** * Construct the jax-rs Provider for OData media type. * @param metadataOData4j * The entity metadata for reading and writing OData entities. * @param metadata * The entity metadata for reading and writing Entity entities. * @param hypermediaEngine * The hypermedia engine contains all the resource to entity mappings * @param transformer * Transformer to convert an entity to a properties map */ public AtomXMLProvider(MetadataOData4j metadataOData4j, Metadata metadata, ResourceStateMachine hypermediaEngine, Transformer transformer) { this(metadataOData4j, metadata, new DefaultResourceStateProvider(hypermediaEngine), hypermediaEngine.getResourceStateByName("ServiceDocument"), transformer); } public AtomXMLProvider(MetadataOData4j metadataOData4j, Metadata metadata, ResourceStateProvider resourceStateProvider, ResourceState serviceDocument, Transformer transformer) { this.metadataOData4j = metadataOData4j; this.metadata = metadata; this.resourceStateProvider = resourceStateProvider; assert resourceStateProvider != null; this.serviceDocument = serviceDocument; if (serviceDocument == null) throw new RuntimeException("No 'ServiceDocument' found."); assert metadata != null; this.transformer = transformer; entryWriter = new AtomEntryFormatWriter(serviceDocument); feedWriter = new AtomFeedFormatWriter(serviceDocument); entityEntryWriter = new AtomEntityEntryFormatWriter(serviceDocument, metadata); this.uriInfo = new UriInfoImpl(uriInfo); } @Override public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { if (mediaType.isCompatible(MediaType.APPLICATION_ATOM_XML_TYPE) // good old Microsoft Excel 2013 has forced us to need to accept this media type (which is completely wrong) https://github.com/temenostech/IRIS/issues/154 || mediaType.equals(ExtendedMediaTypes.APPLICATION_ATOMSVC_XML_TYPE) || mediaType.equals(MediaType.APPLICATION_XML_TYPE)) { return ResourceTypeHelper.isType(type, genericType, EntityResource.class) || ResourceTypeHelper.isType(type, genericType, CollectionResource.class, OEntity.class) || ResourceTypeHelper.isType(type, genericType, CollectionResource.class, Entity.class); } return false; } @Override public long getSize(RESTResource t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { return -1; } /** * Writes a Atom (OData) representation of {@link EntityResource} to the output stream. * * @precondition supplied {@link EntityResource} is non null * @precondition {@link EntityResource#getEntity()} returns a valid OEntity, this * provider only supports serialising OEntities * @postcondition non null Atom (OData) XML document written to OutputStream * @invariant valid OutputStream */ @SuppressWarnings("unchecked") @Override public void writeTo(RESTResource resource, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { assert resource != null; assert uriInfo != null; ByteArrayOutputStream buffer = new ByteArrayOutputStream(); RESTResource restResource = processLinks((RESTResource) resource); Collection<Link> processedLinks = restResource.getLinks(); if (ResourceTypeHelper.isType(type, genericType, EntityResource.class, OEntity.class)) { EntityResource<OEntity> entityResource = (EntityResource<OEntity>) resource; OEntity tempEntity = entityResource.getEntity(); EdmEntitySet entitySet = getEdmEntitySet(entityResource.getEntityName()); List<OLink> olinks = formOLinks(entityResource); //Write entry // create OEntity with our EdmEntitySet see issue https://github.com/aphethean/IRIS/issues/20 OEntity oentity = OEntities.create(entitySet, tempEntity.getEntityKey(), tempEntity.getProperties(), null); entryWriter.write(uriInfo, new OutputStreamWriter(buffer, UTF_8), Responses.entity(oentity), entitySet, olinks); } else if (ResourceTypeHelper.isType(type, genericType, EntityResource.class, Entity.class)) { EntityResource<Entity> entityResource = (EntityResource<Entity>) resource; //Write entry Entity entity = entityResource.getEntity(); String entityName = entityResource.getEntityName(); // Write Entity object with Abdera implementation entityEntryWriter.write(uriInfo, new OutputStreamWriter(buffer, UTF_8), entityName, entity, processedLinks, entityResource.getEmbedded()); } else if (ResourceTypeHelper.isType(type, genericType, EntityResource.class)) { EntityResource<Object> entityResource = (EntityResource<Object>) resource; //Links and entity properties Object entity = entityResource.getEntity(); String entityName = entityResource.getEntityName(); EntityProperties props = new EntityProperties(); if (entity != null) { Map<String, Object> objProps = (transformer != null ? transformer : new BeanTransformer()) .transform(entity); if (objProps != null) { for (String propName : objProps.keySet()) { props.setProperty(new EntityProperty(propName, objProps.get(propName))); } } } entityEntryWriter.write(uriInfo, new OutputStreamWriter(buffer, UTF_8), entityName, new Entity(entityName, props), processedLinks, entityResource.getEmbedded()); } else if (ResourceTypeHelper.isType(type, genericType, CollectionResource.class, OEntity.class)) { CollectionResource<OEntity> collectionResource = ((CollectionResource<OEntity>) resource); EdmEntitySet entitySet = getEdmEntitySet(collectionResource.getEntityName()); List<EntityResource<OEntity>> collectionEntities = (List<EntityResource<OEntity>>) collectionResource .getEntities(); List<OEntity> entities = new ArrayList<OEntity>(); Map<OEntity, Collection<Link>> linkId = new HashMap<OEntity, Collection<Link>>(); for (EntityResource<OEntity> collectionEntity : collectionEntities) { // create OEntity with our EdmEntitySet see issue https://github.com/aphethean/IRIS/issues/20 OEntity tempEntity = collectionEntity.getEntity(); List<OLink> olinks = formOLinks(collectionEntity); Collection<Link> links = collectionEntity.getLinks(); OEntity entity = OEntities.create(entitySet, null, tempEntity.getEntityKey(), tempEntity.getEntityTag(), tempEntity.getProperties(), olinks); entities.add(entity); linkId.put(entity, links); } // TODO implement collection properties and get transient value for skiptoken Integer inlineCount = collectionResource.getInlineCount(); String skipToken = null; feedWriter.write(uriInfo, new OutputStreamWriter(buffer, UTF_8), processedLinks, Responses.entities(entities, entitySet, inlineCount, skipToken), metadata.getModelName(), linkId); } else if (ResourceTypeHelper.isType(type, genericType, CollectionResource.class, Entity.class)) { CollectionResource<Entity> collectionResource = ((CollectionResource<Entity>) resource); // TODO implement collection properties and get transient value for skiptoken Integer inlineCount = collectionResource.getInlineCount(); String skipToken = null; //Write feed AtomEntityFeedFormatWriter entityFeedWriter = new AtomEntityFeedFormatWriter(serviceDocument, metadata); entityFeedWriter.write(uriInfo, new OutputStreamWriter(buffer, UTF_8), collectionResource, inlineCount, skipToken, metadata.getModelName()); } else { LOGGER.error("Accepted object for writing in isWriteable, but type not supported in writeTo method"); throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR); } //Set response headers if (httpHeaders != null) { httpHeaders.putSingle(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_ATOM_XML); //Workaround for https://issues.apache.org/jira/browse/WINK-374 httpHeaders.putSingle(HttpHeaders.CONTENT_LENGTH, Integer.toString(buffer.size())); } IOUtils.copy(new ByteArrayInputStream(buffer.toByteArray()), entityStream); } public RESTResource processLinks(RESTResource restResource) { Collection<Link> linksCollection = restResource.getLinks(); List<Link> processedLinks = new ArrayList<Link>(); if (linksCollection != null) { for (Link linkToAdd : linksCollection) { Link link = linkInterceptor.addingLink(restResource, linkToAdd); if (link != null) { processedLinks.add(link); } } } restResource.setLinks(processedLinks); // process embedded resources if (restResource.getEmbedded() != null) { Map<Transition, RESTResource> embeddedResources = restResource.getEmbedded(); for (RESTResource embeddedResource : embeddedResources.values()) { processLinks(embeddedResource); } } // process entities in collection resource if (restResource instanceof CollectionResource) { CollectionResource<?> collectionResource = (CollectionResource<?>) restResource; for (EntityResource<?> entityResource : collectionResource.getEntities()) { processLinks(entityResource); } } return restResource; } public List<OLink> formOLinks(EntityResource<OEntity> entityResource) { // Create embedded resources from $expand addExpandedLinks(entityResource); //Add entity links List<OLink> olinks = new ArrayList<OLink>(); if (entityResource.getLinks() != null && !entityResource.getLinks().isEmpty()) { for (Link link : entityResource.getLinks()) { addLinkToOLinks(olinks, link, entityResource); } } return olinks; } /* * Using the supplied EntityResource, add the embedded resources * from the OEntity embedded resources. NB - only an OEntity can * carry OLinks. */ public void addExpandedLinks(EntityResource<OEntity> entityResource) { RequestContext requestContext = RequestContext.getRequestContext(); Collection<Link> links = entityResource.getLinks(); if (links != null) { OEntity oentity = entityResource.getEntity(); List<OLink> olinks = oentity.getLinks(); for (OLink olink : olinks) { if (olink.isInline()) { String relid = InternalUtil.getEntityRelId(oentity); String href = relid + "/" + olink.getTitle(); for (Link link : links) { String linkHref = link.getHref(); if (requestContext != null) { //Extract the transition fragment from the URI path linkHref = link.getRelativeHref(getBaseUri(serviceDocument, uriInfo)); } if (href.equals(linkHref)) { if (entityResource.getEmbedded() == null) { entityResource.setEmbedded(new HashMap<Transition, RESTResource>()); } if (olink.isCollection()) { List<OEntity> oentities = olink.getRelatedEntities(); Collection<EntityResource<OEntity>> entityResources = new ArrayList<EntityResource<OEntity>>(); for (OEntity oe : oentities) { entityResources.add(new EntityResource<OEntity>(oe)); } entityResource.getEmbedded().put(link.getTransition(), new CollectionResource<OEntity>(entityResources)); } else { // replace the OLink's on the current entity OEntity inlineOentity = olink.getRelatedEntity(); List<OLink> inlineResourceOlinks = formOLinks( new EntityResource<OEntity>(inlineOentity)); OEntity newInlineOentity = OEntities.create(inlineOentity.getEntitySet(), inlineOentity.getEntityKey(), inlineOentity.getProperties(), inlineResourceOlinks); entityResource.getEmbedded().put(link.getTransition(), new EntityResource<OEntity>(newInlineOentity)); } } } } } } } private void addLinkToOLinks(List<OLink> olinks, Link link, RESTResource resource) { RequestContext requestContext = RequestContext.getRequestContext(); assert link != null; assert link.getTransition() != null; Map<Transition, RESTResource> embeddedResources = resource.getEmbedded(); String rel = link.getRel(); String href = link.getHref(); if (requestContext != null) { //Extract the transition fragment from the URI path href = link.getRelativeHref(getBaseUri(serviceDocument, uriInfo)); } String title = link.getTitle(); OLink olink = null; Transition linkTransition = link.getTransition(); if (linkTransition != null) { if (embeddedResources != null && embeddedResources.get(linkTransition) != null && embeddedResources.get(linkTransition) instanceof EntityResource) { @SuppressWarnings("unchecked") EntityResource<OEntity> embeddedResource = (EntityResource<OEntity>) embeddedResources .get(linkTransition); // replace the OLink's on the embedded entity OEntity newEmbeddedEntity = processOEntity(embeddedResource); olink = OLinks.relatedEntityInline(rel, title, href, newEmbeddedEntity); } else if (embeddedResources != null && embeddedResources.get(linkTransition) != null && embeddedResources.get(linkTransition) instanceof CollectionResource) { @SuppressWarnings("unchecked") CollectionResource<OEntity> embeddedCollectionResource = (CollectionResource<OEntity>) embeddedResources .get(linkTransition); List<OEntity> entities = new ArrayList<OEntity>(); for (EntityResource<OEntity> embeddedResource : embeddedCollectionResource.getEntities()) { // replace the OLink's on the embedded entity OEntity newEmbeddedEntity = processOEntity(embeddedResource); entities.add(newEmbeddedEntity); } olink = OLinks.relatedEntitiesInline(rel, title, href, entities); } if (olink == null) { if (linkTransition.getTarget() instanceof CollectionResourceState) { olink = OLinks.relatedEntities(rel, title, href); } else { olink = OLinks.relatedEntity(rel, title, href); } } } olinks.add(olink); } private OEntity processOEntity(EntityResource<OEntity> entityResource) { List<OLink> embeddedLinks = formOLinks(entityResource); OEntity embeddedEntity = entityResource.getEntity(); // replace the OLink's on the embedded entity OEntity newOEntity = OEntities.create(embeddedEntity.getEntitySet(), embeddedEntity.getEntityKey(), embeddedEntity.getProperties(), embeddedLinks); return newOEntity; } @Override public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { // this class can only deserialise EntityResource with OEntity return ResourceTypeHelper.isType(type, genericType, EntityResource.class); } /** * Reads a Atom (OData) representation of {@link EntityResource} from the input stream. * * @precondition {@link InputStream} contains a valid Atom (OData) Entity enclosed in a <resource/> document * @postcondition {@link EntityResource} will be constructed and returned. * @invariant valid InputStream */ @Override public EntityResource<OEntity> readFrom(Class<RESTResource> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { // check media type can be handled, isReadable must have been called assert ResourceTypeHelper.isType(type, genericType, EntityResource.class); assert mediaType.isCompatible(MediaType.APPLICATION_ATOM_XML_TYPE); try { OEntityKey entityKey = null; // work out the entity name using resource path from UriInfo String absoluteUri = uriInfo.getAbsolutePath().toString(); String resourcePath = absoluteUri.substring(uriInfo.getBaseUri().toString().length()); ResourceState currentState = null; try { currentState = getCurrentState(serviceDocument, resourcePath); } catch (MethodNotAllowedException e1) { StringBuilder allowHeader = new StringBuilder(); Set<String> allowedMethods = new HashSet<String>(e1.getAllowedMethods()); allowedMethods.add("HEAD"); allowedMethods.add("OPTIONS"); for (String method : allowedMethods) { allowHeader.append(method); allowHeader.append(", "); } Response response = Response.status(405) .header("Allow", allowHeader.toString().substring(0, allowHeader.length() - 2)).build(); throw new WebApplicationException(e1, response); } if (currentState == null) throw new IllegalStateException("No state found"); String pathIdParameter = getPathIdParameter(currentState); UriInfo tmpUriInfo = new UriInfoImpl(uriInfo); String uriPath = uriInfo.getAbsolutePath().toString() .substring(uriInfo.getBaseUri().toString().length()); if (uriPath.charAt(0) == '/') { uriPath = uriPath.substring(1); } String statePath = currentState.getPath(); if (statePath.charAt(0) == '/') { statePath = statePath.substring(1); } new URLHelper().extractPathParameters(tmpUriInfo, uriPath.split("/"), statePath.split("/")); MultivaluedMap<String, String> pathParameters = tmpUriInfo.getPathParameters(); if (pathParameters != null && pathParameters.getFirst(pathIdParameter) != null) { if (STRING_KEY_RESOURCE_PATTERN.matcher(resourcePath).find()) { entityKey = OEntityKey.create(pathParameters.getFirst(pathIdParameter)); } else { entityKey = OEntityKey.parse(pathParameters.getFirst(pathIdParameter)); } } if (currentState.getEntityName() == null) { throw new IllegalStateException("Entity name could not be determined"); } /* * get the entity set name using the metadata */ String entitySetName = getEntitySet(currentState); // Check contents of the stream, if empty or null then return empty resource InputStream verifiedStream = verifyContentReceieved(entityStream); if (verifiedStream == null) { return new EntityResource<OEntity>(); } // Lets parse the request content Reader reader = new InputStreamReader(verifiedStream); assert entitySetName != null : "Must have found a resource or thrown exception"; Entry e = new AtomEntryFormatParserExt(metadataOData4j, entitySetName, entityKey, null).parse(reader); return new EntityResource<OEntity>(e.getEntity()); } catch (IllegalStateException e) { LOGGER.warn("Malformed request from client", e); throw new WebApplicationException(Status.BAD_REQUEST); } } /* * Find the entity set name for this resource */ public String getEntitySet(ResourceState state) { String entitySetName = null; String fqTargetEntityName = metadata.getModelName() + Metadata.MODEL_SUFFIX + "." + state.getEntityName(); try { EdmEntityType targetEntityType = (EdmEntityType) getEdmDataService() .findEdmEntityType(fqTargetEntityName); if (targetEntityType != null) { EdmEntitySet targetEntitySet = getEdmDataService().getEdmEntitySet(targetEntityType); if (targetEntitySet != null) entitySetName = targetEntitySet.getName(); } } catch (NotFoundException e) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Failed to get entity set name", e); } } if (entitySetName == null) { try { entitySetName = getEdmEntitySet(state.getEntityName()).getName(); } catch (NotFoundException e) { LOGGER.warn("Entity [" + fqTargetEntityName + "] is not an entity set.", e); } if (entitySetName == null) { entitySetName = state.getName(); } } return entitySetName; } protected ResourceState getCurrentState(ResourceState serviceDocument, String resourcePath) throws MethodNotAllowedException { ResourceState state = null; if (resourcePath != null) { String tmpResourcePath = uriInfo.getAbsolutePath().toString() .replaceFirst(uriInfo.getBaseUri().toString(), ""); if (tmpResourcePath.charAt(0) != '/') { tmpResourcePath = '/' + tmpResourcePath; } state = resourceStateProvider.getResourceState(requestContext.getMethod(), tmpResourcePath); } return state; } /* * For a given resource state, get the path parameter used for the id. * @param state * @return */ private String getPathIdParameter(ResourceState state) { String pathIdParameter = InteractionContext.DEFAULT_ID_PATH_ELEMENT; if (state.getPathIdParameter() != null) { pathIdParameter = state.getPathIdParameter(); } return pathIdParameter; } /* Ugly testing support :-( */ void setUriInfo(UriInfo uriInfo) { this.uriInfo = uriInfo; if (resourceStateProvider instanceof DefaultResourceStateProvider) { ((DefaultResourceStateProvider) resourceStateProvider).setUriInfo(uriInfo); } } void setRequestContext(Request request) { this.requestContext = request; } void setResourceStateProvider(ResourceStateProvider resourceStateProvider) { this.resourceStateProvider = resourceStateProvider; } /** * Method to verify if receieved stream has content or its empty * @param stream Stream to check * @return verified stream * @throws IOException */ private InputStream verifyContentReceieved(InputStream stream) throws IOException { if (stream == null) { // Check if its null LOGGER.debug("Request stream received as null"); return null; } else if (stream.markSupported()) { // Check stream supports mark/reset // mark() and read the first byte just to check stream.mark(1); final int bytesRead = stream.read(new byte[1]); if (bytesRead != -1) { //stream not empty stream.reset(); // reset the stream as if untouched return stream; } else { //stream empty LOGGER.debug("Request received with empty body"); return null; } } else { // Panic! this stream does not support mark/reset, try with PushbackInputStream as a last resort int bytesRead; PushbackInputStream pbs = new PushbackInputStream(stream); if ((bytesRead = pbs.read()) != -1) { // Contents detected, unread and return pbs.unread(bytesRead); return pbs; } else { // Empty stream detected LOGGER.debug("Request received with empty body!"); return null; } } } /** * Our base uri is the uri to the service document. * @param serviceDocument * @param uriInfo * @return */ public static String getBaseUri(ResourceState serviceDocument, UriInfo uriInfo) { String baseUri = uriInfo.getBaseUri().toString(); if (serviceDocument.getPath() != null) { if (baseUri.endsWith("/")) { baseUri = baseUri.substring(0, baseUri.lastIndexOf("/")); } baseUri = baseUri + serviceDocument.getPath(); String absPath = getAbsolutePath(uriInfo); baseUri = HypermediaTemplateHelper.getTemplatedBaseUri(baseUri, absPath); if (!baseUri.endsWith("/")) { baseUri += "/"; } } return baseUri; } public static String getAbsolutePath(UriInfo uriInfo) { return uriInfo.getBaseUri() + uriInfo.getPath(); } private EdmDataServices getEdmDataService() { return metadataOData4j.getMetadata(); } /* * get edmEntitySet */ public EdmEntitySet getEdmEntitySet(String entityName) { EdmEntityType entityType = (EdmEntityType) getEdmDataService().findEdmEntityType(entityName); EdmEntitySet entitySet = null; try { entitySet = getEdmDataService().getEdmEntitySet(entityType); } catch (Exception e) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Unable to find entity set for [" + entityName + "]", e); } } if (entitySet == null) { return metadataOData4j.getEdmEntitySetByEntityName(entityName); } return entitySet; } }