/*******************************************************************************
* 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.wink.server.internal.utils;
import java.net.URI;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import javax.ws.rs.HttpMethod;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.UriBuilder;
import org.apache.wink.common.RestConstants;
import org.apache.wink.common.internal.registry.metadata.MethodMetadata;
import org.apache.wink.common.internal.utils.MediaTypeUtils;
import org.apache.wink.common.model.atom.AtomConstants;
import org.apache.wink.common.model.synd.SyndLink;
import org.apache.wink.server.internal.handlers.FindRootResourceHandler;
import org.apache.wink.server.handlers.MessageContext;
import org.apache.wink.server.internal.registry.ResourceInstance;
import org.apache.wink.server.internal.registry.ResourceRecord;
import org.apache.wink.server.internal.registry.SubResourceInstance;
import org.apache.wink.server.utils.SystemLinksBuilder;
public class SystemLinksBuilderImpl extends AbstractLinksBuilderImpl<SystemLinksBuilder> implements
SystemLinksBuilder {
private LinkType[] types;
private boolean allResources;
public SystemLinksBuilderImpl(MessageContext context) {
super(context);
types = null;
allResources = isContinuedSearchMode();
}
protected boolean isContinuedSearchMode() {
return Boolean.valueOf(context.getProperties()
.getProperty(FindRootResourceHandler.SEARCH_POLICY_CONTINUED_SEARCH_KEY, "false")); //$NON-NLS-1$
}
public SystemLinksBuilder types(LinkType... types) {
this.types = types;
return this;
}
public SystemLinksBuilder allResources(boolean all) {
allResources = all;
return this;
}
@Override
public List<SyndLink> build(List<SyndLink> out) {
Set<SyndLink> set = new HashSet<SyndLink>();
// if the search mode is "Continued Search" we need to generate links
// for all
// of the matching root resources and not just for the current one
if (allResources) {
// get the path to use for obtaining the matching root resources
URI uri = UriBuilder.fromPath(resourcePath).buildFromEncodedMap(pathParams);
String path = uri.toString();
List<ResourceInstance> rootResources = registry.getMatchingRootResources(path);
// go over all the root matching resources and generate links for
// them
for (ResourceInstance rootResource : rootResources) {
UriBuilder uriBuilder = initUriBuilder(path);
ResourceRecord record = rootResource.getRecord();
build(set, uriBuilder, record);
}
} else {
// generate links just for this one resource
UriBuilder uriBuilder = initUriBuilder();
build(set, uriBuilder, record);
}
if (out == null) {
out = new LinkedList<SyndLink>();
}
out.addAll(set);
return out;
}
private Set<SyndLink> build(Set<SyndLink> set, UriBuilder selfUriBuilder, ResourceRecord record) {
List<MethodMetadata> methods = null;
if (subResourcePath != null && subResourcePath.length() > 0) {
// 1) find all the sub-resources that match the sub-resource path
List<SubResourceInstance> subResources =
record.getMatchingSubResourceMethods(subResourcePath);
methods = new LinkedList<MethodMetadata>();
for (SubResourceInstance sub : subResources) {
methods.add(sub.getMetadata());
}
// 2) add the sub-resource path to the uri builder
selfUriBuilder.path(subResourcePath);
} else {
methods = record.getMetadata().getResourceMethods();
}
return build(set, selfUriBuilder, methods);
}
private Set<SyndLink> build(Set<SyndLink> set,
UriBuilder selfUriBuilder,
List<MethodMetadata> methods) {
// add all query parameters to the self uri
for (String query : queryParams.keySet()) {
selfUriBuilder.queryParam(query, queryParams.get(query).toArray());
}
// get a set of the required links to generate
Set<LinkType> systemLinksToGenerate = generateSystemLinksSet();
// self link; should not be created if wasn't requested.
// self link; not replace it if some already exists
URI selfUri = selfUriBuilder.buildFromEncodedMap(pathParams);
if (systemLinksToGenerate.contains(LinkType.SELF) && getLink(set,
AtomConstants.ATOM_REL_SELF) == null) {
set.add(createLink(AtomConstants.ATOM_REL_SELF, null, selfUri));
}
// edit link; should not be created if wasn't requested.
// edit link if the Resource has an update operation; does not replace
// it if it already
// exists
if (systemLinksToGenerate.contains(LinkType.EDIT) && getLink(set,
AtomConstants.ATOM_REL_EDIT) == null) {
for (MethodMetadata methodRecord : methods) {
String httpMethod = methodRecord.getHttpMethod();
if (httpMethod.equalsIgnoreCase(HttpMethod.PUT) || httpMethod
.equalsIgnoreCase(HttpMethod.DELETE)) {
set.add(createLink(AtomConstants.ATOM_REL_EDIT, null, selfUri));
break;
}
}
}
// alternate links - all GET operations
Set<MediaType> producedTypesForGet = getProducedTypesForGet(methods);
for (MediaType mediaType : producedTypesForGet) {
if (addAltParam && queryParams.get(RestConstants.REST_PARAM_MEDIA_TYPE) == null) {
selfUriBuilder.replaceQueryParam(RestConstants.REST_PARAM_MEDIA_TYPE,
MediaTypeUtils.toEncodedString(mediaType));
}
URI href = selfUriBuilder.buildFromEncodedMap(pathParams);
if (MediaTypeUtils.equalsIgnoreParameters(mediaType, MediaTypeUtils.OPENSEARCH_TYPE)) {
if (systemLinksToGenerate.contains(LinkType.OPENSEARCH)) {
// open search link; should not be created if wasn't
// requested.
set.add(createLink(AtomConstants.ATOM_REL_SEARCH, mediaType, href));
}
} else if (systemLinksToGenerate.contains(LinkType.ALTERNATE)) {
set.add(createLink(AtomConstants.ATOM_REL_ALT, mediaType, href));
}
}
return set;
}
private static Set<MediaType> getProducedTypesForGet(List<MethodMetadata> methods) {
Set<MediaType> getResponses = new LinkedHashSet<MediaType>();
if (methods != null) {
for (MethodMetadata methodRecord : methods) {
if (methodRecord.getHttpMethod().equals(HttpMethod.GET)) {
getResponses.addAll(methodRecord.getProduces());
}
}
}
return getResponses;
}
private Set<LinkType> generateSystemLinksSet() {
Set<LinkType> systemLinksSet = new HashSet<LinkType>();
if (types == null || types.length == 0) {
for (LinkType type : LinkType.values()) {
systemLinksSet.add(type);
}
} else {
for (LinkType type : types) {
systemLinksSet.add(type);
}
}
return systemLinksSet;
}
}