/*
* 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.common.model.wadl;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.FormParam;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.MatrixParam;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.xml.namespace.QName;
import org.apache.wink.common.DynamicResource;
import org.apache.wink.common.internal.registry.Injectable;
import org.apache.wink.common.internal.registry.Injectable.ParamType;
import org.apache.wink.common.internal.registry.metadata.ClassMetadata;
import org.apache.wink.common.internal.registry.metadata.MethodMetadata;
import org.apache.wink.common.internal.registry.metadata.ResourceMetadataCollector;
import org.apache.wink.common.internal.uritemplate.JaxRsUriTemplateProcessor;
import org.apache.wink.common.internal.uritemplate.UriTemplateProcessor;
/**
* @Path("/sfdsf"); public class MyResource {
* @Context javax.ws.rs.core.Application app;
* @OPTIONS public org.apache.wink.common.model.wadl.Application getWADL() {
* return new WADLGenerator().generate(app.getClasses()); } }
*/
public class WADLGenerator {
private static final String XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema";
public Application generate(String baseURI, Set<Class<?>> classes) {
/*
* the idea is that classes comes from the Application subclass
*/
Application app = new Application();
if (classes == null || classes.isEmpty()) {
return app;
}
Resources resources = new Resources();
resources.setBase(baseURI);
Set<ClassMetadata> metadataSet = buildClassMetdata(classes);
resources.getResource().addAll(buildResources(metadataSet));
app.getResources().add(resources);
return app;
}
/* package */Set<ClassMetadata> buildClassMetdata(Set<Class<?>> classes) {
Set<ClassMetadata> metadataSet = new HashSet<ClassMetadata>(classes.size());
for (Class<?> c : classes) {
if (!isResource(c)) {
/* not a resource, so skip it */
continue;
}
ClassMetadata metadata = ResourceMetadataCollector.collectMetadata(c);
metadataSet.add(metadata);
}
return metadataSet;
}
/* package */Set<Resource> buildResources(Set<ClassMetadata> metadataSet) {
Set<Resource> s = new HashSet<Resource>(metadataSet.size());
for (ClassMetadata metadata : metadataSet) {
Resource r = buildResource(metadata);
s.add(r);
}
return s;
}
/* package */Resource buildResource(ClassMetadata metadata) {
Resource r = new Resource();
if (metadata != null) {
Class<?> resClass = metadata.getResourceClass();
if (resClass != null) {
WADLDoc d = resClass.getAnnotation(WADLDoc.class);
if (d != null) {
r.getDoc().add(getDocument(d));
}
}
}
/* set the path */
String path = metadata.getPath();
if (path == null) {
Class<?> resClass = metadata.getResourceClass();
if (DynamicResource.class.isAssignableFrom(resClass)) {
try {
DynamicResource dynRes = (DynamicResource)resClass.newInstance();
path = dynRes.getPath();
} catch (Exception e) {
// Drop through and look for @Path annotation.
}
}
}
UriTemplateProcessor processor = JaxRsUriTemplateProcessor.newNormalizedInstance(path);
String pathStr = processor.getTemplate();
for (String var : processor.getVariableNames()) {
pathStr = pathStr.replaceAll("\\{(\\s)*" + var + "(\\s)*:.*\\}", "{" + var + "}");
}
r.setPath(pathStr);
List<Object> methodOrSubresource = r.getMethodOrResource();
List<Param> resourceParams = r.getParam();
List<MethodMetadata> methodMetadata = metadata.getResourceMethods();
if (methodMetadata != null && !methodMetadata.isEmpty()) {
for (MethodMetadata methodMeta : methodMetadata) {
Method m = buildMethod(metadata, methodMeta);
methodOrSubresource.add(m);
/* also scan for all the path and matrix parameters */
List<Injectable> params = methodMeta.getFormalParameters();
if (params != null && params.size() > 0) {
for (Injectable p : params) {
Param param = null;
boolean isUnique = true;
switch (p.getParamType()) {
case QUERY:
/* do nothing */
break;
case HEADER:
/* do nothing */
break;
case ENTITY:
/* do nothing */
break;
case COOKIE:
/* not supported in WADL */
break;
case FORM:
/* should show up in the representation instead */
break;
case PATH:
param = buildParam(p);
for (Param rParam : resourceParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
resourceParams.add(param);
}
break;
case MATRIX:
param = buildParam(p);
for (Param rParam : resourceParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
resourceParams.add(param);
}
break;
case CONTEXT:
/* do nothing */
break;
}
}
}
}
}
/*
* list the class level parameters
*/
List<Injectable> fields = metadata.getInjectableFields();
if (fields != null) {
for (Injectable p : metadata.getInjectableFields()) {
Param param = null;
boolean isUnique = true;
switch (p.getParamType()) {
case QUERY:
resourceParams.add(buildParam(p));
break;
case HEADER:
resourceParams.add(buildParam(p));
break;
case ENTITY:
/* do nothing */
break;
case COOKIE:
/* not supported in WADL */
break;
case FORM:
/* should show up in the representation instead */
break;
case PATH:
param = buildParam(p);
for (Param rParam : resourceParams) {
if (param.getName() != null && param.getName().equals(rParam.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
resourceParams.add(param);
}
break;
case MATRIX:
param = buildParam(p);
for (Param rParam : resourceParams) {
if (param.getName() != null && param.getName().equals(rParam.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
resourceParams.add(param);
}
break;
case CONTEXT:
/* do nothing */
break;
}
}
}
/*
* list subresource methods
*/
methodMetadata = metadata.getSubResourceMethods();
if (methodMetadata != null && !methodMetadata.isEmpty()) {
for (MethodMetadata methodMeta : methodMetadata) {
Resource subRes = new Resource();
Method m = buildMethod(metadata, methodMeta);
subRes.getMethodOrResource().add(m);
subRes.setPath(methodMeta.getPath());
methodOrSubresource.add(subRes);
List<Param> subResParams = subRes.getParam();
/* also scan for all the path and matrix parameters */
List<Injectable> params = methodMeta.getFormalParameters();
if (params != null && params.size() > 0) {
for (Injectable p : params) {
Param param = null;
boolean isUnique = true;
switch (p.getParamType()) {
case QUERY:
/* do nothing */
break;
case HEADER:
/* do nothing */
break;
case ENTITY:
/* do nothing */
break;
case COOKIE:
/* not supported in WADL */
break;
case FORM:
/* should show up in the representation instead */
break;
case PATH:
param = buildParam(p);
for (Param rParam : subResParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
subRes.getParam().add(param);
}
break;
case MATRIX:
param = buildParam(p);
for (Param rParam : subResParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
subRes.getParam().add(param);
}
break;
case CONTEXT:
/* do nothing */
break;
}
}
}
}
}
/*
* list subresource locators
*/
methodMetadata = metadata.getSubResourceLocators();
if (methodMetadata != null && !methodMetadata.isEmpty()) {
for (MethodMetadata methodMeta : methodMetadata) {
Resource subRes = new Resource();
subRes.setPath(methodMeta.getPath());
if (methodMeta != null) {
java.lang.reflect.Method reflMethod = methodMeta.getReflectionMethod();
if (reflMethod != null) {
WADLDoc d = reflMethod.getAnnotation(WADLDoc.class);
if (d != null) {
subRes.getDoc().add(getDocument(d));
}
}
}
methodOrSubresource.add(subRes);
/* also scan for all the path and matrix parameters */
List<Injectable> params = methodMeta.getFormalParameters();
List<Param> subResParams = subRes.getParam();
if (params != null && params.size() > 0) {
for (Injectable p : params) {
Param param = null;
boolean isUnique = true;
switch (p.getParamType()) {
case QUERY:
param = buildParam(p);
for (Param rParam : subResParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
subRes.getParam().add(param);
}
break;
case HEADER:
param = buildParam(p);
for (Param rParam : subResParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
subRes.getParam().add(param);
}
break;
case ENTITY:
/* do nothing */
break;
case COOKIE:
/* not supported in WADL */
break;
case FORM:
/* should show up in the representation instead */
break;
case PATH:
param = buildParam(p);
for (Param rParam : subResParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
subRes.getParam().add(param);
}
break;
case MATRIX:
param = buildParam(p);
for (Param rParam : subResParams) {
if (param.getName() != null && param.getName().equals(rParam
.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
subRes.getParam().add(param);
}
break;
case CONTEXT:
/* do nothing */
break;
}
}
}
}
}
return r;
}
/* package */Method buildMethod(ClassMetadata classMetadata, MethodMetadata metadata) {
Method m = new Method();
m.setName(metadata.getHttpMethod());
java.lang.reflect.Method reflMethod = metadata.getReflectionMethod();
if (reflMethod != null) {
WADLDoc d = reflMethod.getAnnotation(WADLDoc.class);
if (d != null) {
m.getDoc().add(getDocument(d));
}
}
Request r = buildRequest(classMetadata, metadata);
if (r != null) {
m.setRequest(r);
}
List<Response> resp = buildResponse(metadata);
if (resp != null) {
m.getResponse().addAll(resp);
}
return m;
}
/* package */Request buildRequest(ClassMetadata classMetadata, MethodMetadata metadata) {
Request r = null;
List<Injectable> params = metadata.getFormalParameters();
if (params != null && params.size() > 0) {
if (r == null) {
r = new Request();
}
boolean hasValidParams = false;
List<Param> requestParams = r.getParam();
for (Injectable p : params) {
Param param = null;
boolean isUnique = true;
switch (p.getParamType()) {
case QUERY:
hasValidParams = true;
param = buildParam(p);
for (Param rParam : requestParams) {
if (param.getName() != null && param.getName().equals(rParam.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
requestParams.add(buildParam(p));
}
break;
case HEADER:
hasValidParams = true;
param = buildParam(p);
for (Param rParam : requestParams) {
if (param.getName() != null && param.getName().equals(rParam.getName())
&& rParam.getStyle().equals(param.getStyle())) {
isUnique = false;
}
}
if (isUnique) {
requestParams.add(buildParam(p));
}
break;
case ENTITY:
hasValidParams = true;
Annotation[] anns = p.getAnnotations();
if (anns != null && anns.length > 0) {
for (Annotation a : anns) {
if (WADLDoc.class.equals(a.annotationType())) {
WADLDoc d = (WADLDoc)a;
r.getDoc().add(getDocument(d));
}
}
}
/* need to build the representation */
Set<Representation> representations =
buildIncomingRepresentation(classMetadata, metadata, p);
if (representations != null)
r.getRepresentation().addAll(representations);
break;
case COOKIE:
/* not supported in WADL */
break;
case FORM:
/* should show up in the representation instead */
break;
case PATH:
/* should show up in the containing resource */
break;
case MATRIX:
/* should show up in the containing resource */
break;
case CONTEXT:
/* do nothing */
break;
}
}
if (!hasValidParams) {
r = null;
}
}
return r;
}
/* package */Param buildParam(Injectable paramMetadata) {
Param p = null;
ParamType pt = paramMetadata.getParamType();
Annotation[] annotations = paramMetadata.getAnnotations();
switch (pt) {
case HEADER:
p = new Param();
p.setStyle(ParamStyle.HEADER);
if (annotations != null) {
for (Annotation a : annotations) {
if (HeaderParam.class.equals(a.annotationType())) {
HeaderParam paramAnn = (HeaderParam)a;
p.setName(paramAnn.value());
}
}
}
break;
case MATRIX:
p = new Param();
p.setStyle(ParamStyle.MATRIX);
for (Annotation a : annotations) {
if (MatrixParam.class.equals(a.annotationType())) {
MatrixParam paramAnn = (MatrixParam)a;
p.setName(paramAnn.value());
}
}
break;
case PATH:
p = new Param();
p.setStyle(ParamStyle.TEMPLATE);
for (Annotation a : annotations) {
if (PathParam.class.equals(a.annotationType())) {
PathParam paramAnn = (PathParam)a;
p.setName(paramAnn.value());
}
}
break;
case QUERY:
p = new Param();
p.setStyle(ParamStyle.QUERY);
for (Annotation a : annotations) {
if (QueryParam.class.equals(a.annotationType())) {
QueryParam paramAnn = (QueryParam)a;
p.setName(paramAnn.value());
}
}
break;
case FORM:
p = new Param();
p.setStyle(ParamStyle.QUERY);
for (Annotation a : annotations) {
if (FormParam.class.equals(a.annotationType())) {
FormParam paramAnn = (FormParam)a;
p.setName(paramAnn.value());
}
}
break;
case CONTEXT:
break;
case COOKIE:
break;
case ENTITY:
break;
}
if (p == null) {
/*
* The paramtype was never set so return null. This might have been
* some other type of injectable that shouldn't be created as a
* Param. This is a preventive measure.
*/
return null;
}
Class<?> memberType = paramMetadata.getType();
if (memberType.equals(int.class) || memberType.equals(Integer.class)) {
p.setType(new QName(XML_SCHEMA_NS, "int"));
} else if (memberType.equals(float.class) || memberType.equals(Float.class)) {
p.setType(new QName(XML_SCHEMA_NS, "float"));
} else if (memberType.equals(long.class) || memberType.equals(Long.class)) {
p.setType(new QName(XML_SCHEMA_NS, "long"));
} else if (memberType.equals(boolean.class) || memberType.equals(Boolean.class)) {
p.setType(new QName(XML_SCHEMA_NS, "boolean"));
} else if (memberType.equals(short.class) || memberType.equals(Short.class)) {
p.setType(new QName(XML_SCHEMA_NS, "short"));
} else if (memberType.equals(double.class) || memberType.equals(Double.class)) {
p.setType(new QName(XML_SCHEMA_NS, "double"));
} else if (memberType.equals(byte.class) || memberType.equals(Byte.class)) {
p.setType(new QName(XML_SCHEMA_NS, "byte"));
}
for (Annotation a : annotations) {
if (DefaultValue.class.equals(a.annotationType())) {
DefaultValue paramAnn = (DefaultValue)a;
p.setDefault(paramAnn.value());
}
if (WADLDoc.class.equals(a.annotationType())) {
WADLDoc d = (WADLDoc)a;
p.getDoc().add(getDocument(d));
}
}
return p;
}
/* package */Set<Representation> buildIncomingRepresentation(ClassMetadata classMetadata,
MethodMetadata methodMetadata,
Injectable metadata) {
if (methodMetadata == null) {
return null;
}
if (metadata != null && metadata.getParamType() != ParamType.ENTITY) {
throw new IllegalArgumentException("Parameter data is not for an entity.");
}
/*
* first check all the consumes
*/
Set<MediaType> consumesMT = methodMetadata.getConsumes();
Set<Representation> reps = null;
if (consumesMT != null && !consumesMT.isEmpty()) {
reps = new HashSet<Representation>();
for (MediaType mt : consumesMT) {
Representation r = new Representation();
r.setMediaType(mt.toString());
/*
* if the representation is a special case, we need to build for
* it
*/
/*
* special cases include application/xml, text/xml; should set
* the element attribute
*/
List<Param> params = new ArrayList<Param>();
if (mt.isCompatible(MediaType.APPLICATION_FORM_URLENCODED_TYPE) || mt
.isCompatible(MediaType.MULTIPART_FORM_DATA_TYPE)) {
List<Injectable> injectables = methodMetadata.getFormalParameters();
if (injectables != null) {
for (Injectable i : injectables) {
if (ParamType.FORM.equals(i.getParamType())) {
params.add(buildParam(i));
}
}
}
/*
* should we scan the class metadata too? FormParams aren't
* required to be supported in other places than the
* resource method parameters
*/
if (!params.isEmpty()) {
r.getParam().addAll(params);
}
}
reps.add(r);
}
} else {
if (metadata == null) {
return null;
}
/*
* there aren't any consumes so we can't look for that but maybe we
* can look at the Providers registry and find all the relevant
* media types there
*/
}
return reps;
}
/* package */List<Response> buildResponse(MethodMetadata metadata) {
if (metadata == null) {
return null;
}
Response r = null;
// Set<MediaType> produces = metadata.getProduces();
Set<Representation> representations = buildOutgoingRepresentation(metadata, null);
if (representations != null && !representations.isEmpty()) {
r = new Response();
r.getRepresentation().addAll(representations);
}
java.lang.reflect.Method m = metadata.getReflectionMethod();
if (Void.TYPE.equals(m.getReturnType())) {
if (r == null) {
r = new Response();
}
r.getStatus().add(Long.valueOf(204));
} else if (!javax.ws.rs.core.Response.class.isAssignableFrom(m.getReturnType())) {
if (r == null) {
r = new Response();
}
r.getStatus().add(Long.valueOf(200));
}
return Collections.singletonList(r);
}
/* package */Set<Representation> buildOutgoingRepresentation(MethodMetadata methodMetadata,
Class<?> returnType) {
if (methodMetadata == null) {
return null;
}
/*
* first check all the consumes
*/
Set<MediaType> producesMT = methodMetadata.getProduces();
Set<Representation> reps = null;
if (producesMT != null && !producesMT.isEmpty()) {
reps = new HashSet<Representation>();
for (MediaType mt : producesMT) {
Representation r = new Representation();
r.setMediaType(mt.toString());
/*
* if the representation is a special case, we need to build for
* it
*/
/*
* TODO: special cases include application/xml, text/xml; should
* set the element attribute
*/
reps.add(r);
}
} else {
/*
* there aren't any produces so we can't look for that but maybe we
* can look at the Providers registry and find all the relevant
* media types there
*/
}
return reps;
}
/* package */Doc getDocument(WADLDoc desc) {
Doc d = new Doc();
d.setTitle(desc.value());
if (!"".equals(desc.content())) {
d.getContent().add(desc.content());
}
return d;
}
/*
* Customized isResource method so it accepts interfaces.
*/
protected boolean isResource(Class<?> cls) {
if (ResourceMetadataCollector.isDynamicResource(cls)) {
return true;
}
if (cls.getAnnotation(Path.class) != null) {
return true;
}
Class<?> declaringClass = cls;
while (!declaringClass.equals(Object.class)) {
// try a superclass
Class<?> superclass = declaringClass.getSuperclass();
if (superclass.getAnnotation(Path.class) != null) {
return true;
}
// try interfaces
Class<?>[] interfaces = declaringClass.getInterfaces();
for (Class<?> interfaceClass : interfaces) {
if (interfaceClass.getAnnotation(Path.class) != null) {
return true;
}
}
declaringClass = declaringClass.getSuperclass();
}
return false;
}
}