org.netbeans.modules.websvc.rest.RestUtils Maven / Gradle / Ivy
/*
* 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.netbeans.modules.websvc.rest;
import com.sun.source.tree.AnnotationTree;
import com.sun.source.tree.ClassTree;
import com.sun.source.tree.ExpressionTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.ModifiersTree;
import com.sun.source.tree.ParameterizedTypeTree;
import com.sun.source.tree.Tree;
import com.sun.source.tree.TypeParameterTree;
import com.sun.source.tree.VariableTree;
import com.sun.source.tree.WildcardTree;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Modifier;
import org.netbeans.api.j2ee.core.Profile;
import org.netbeans.api.java.classpath.ClassPath;
import org.netbeans.api.java.source.JavaSource;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule;
import org.netbeans.modules.j2ee.deployment.devmodules.spi.J2eeModuleProvider;
import org.netbeans.modules.web.api.webmodule.WebModule;
import org.netbeans.modules.websvc.rest.spi.RestSupport;
import static org.netbeans.modules.websvc.rest.spi.RestSupport.JAX_RS_APPLICATION_CLASS;
import org.netbeans.modules.websvc.rest.support.JavaSourceHelper;
import org.netbeans.modules.websvc.rest.support.SourceGroupSupport;
import org.openide.filesystems.FileObject;
import javax.xml.xpath.*;
import org.netbeans.api.java.source.Task;
import org.netbeans.api.java.source.TreeMaker;
import org.netbeans.api.java.source.WorkingCopy;
import org.netbeans.modules.j2ee.core.api.support.java.GenerationUtils;
import org.netbeans.modules.j2ee.deployment.common.api.Datasource;
import org.netbeans.modules.web.spi.webmodule.WebModuleProvider;
import org.netbeans.modules.websvc.rest.codegen.Constants;
import org.netbeans.modules.websvc.rest.model.api.RestConstants;
import org.netbeans.modules.websvc.rest.model.api.RestServicesModel;
import org.netbeans.modules.websvc.rest.spi.MiscUtilities;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* REST support utilitities across all project types.
*
* @author Nam Nguyen
*/
public class RestUtils {
public static RestSupport getRestSupport(Project project) {
return project.getLookup().lookup(RestSupport.class);
}
public static RestServicesModel getRestServicesMetadataModel(Project project) {
RestSupport support = getRestSupport(project);
if (support != null) {
return support.getRestServicesModel();
}
return null;
}
public static void disableRestServicesChangeListner(Project project) {
final RestServicesModel wsModel = RestUtils.getRestServicesMetadataModel(project);
if (wsModel == null) {
return;
}
wsModel.disablePropertyChangeListener();
}
public static void enableRestServicesChangeListner(Project project) {
final RestServicesModel wsModel = RestUtils.getRestServicesMetadataModel(project);
if (wsModel == null) {
return;
}
wsModel.enablePropertyChangeListener();
}
public static boolean hasJTASupport(Project project) {
RestSupport support = getRestSupport(project);
if (support != null) {
return support.hasJTASupport();
}
return false;
}
public static FileObject getDeploymentDescriptor(Project p) {
WebModuleProvider wmp = p.getLookup().lookup(WebModuleProvider.class);
if (wmp != null) {
return wmp.findWebModule(p.getProjectDirectory()).getDeploymentDescriptor();
}
return null;
}
public static boolean hasSpringSupport(Project project) {
RestSupport support = getRestSupport(project);
if (support != null) {
return support.hasSpringSupport();
}
return false;
}
public static boolean isServerTomcat(Project project) {
RestSupport support = getRestSupport(project);
if (support != null) {
return support.isServerTomcat();
}
return false;
}
public static boolean isServerGFV3(Project project) {
RestSupport support = getRestSupport(project);
if (support != null) {
return support.isServerGFV3();
}
return false;
}
public static boolean isServerGFV2(Project project) {
RestSupport support = getRestSupport(project);
if (support != null) {
return support.isServerGFV2();
}
return false;
}
public static Datasource getDatasource(Project project, String jndiName) {
return MiscUtilities.getDatasource(project, jndiName);
}
//
// TODO: The following methods don't belong here. Some of them should go into
// JavaSourceHelper and the XML/DOM related methods should go into
// their own utility class.
//
public static String getAttributeValue(Node n, String nodePath, String attrName) throws XPathExpressionException {
String attrValue = null;
XPathFactory factory = XPathFactory.newInstance();
XPath xpath = factory.newXPath();
XPathExpression expr3 = xpath.compile(nodePath+"/@"+attrName);
Object result3 = expr3.evaluate(n, XPathConstants.NODESET);
NodeList nodes3 = (NodeList) result3;
for (int i = 0; i < nodes3.getLength(); i++) {
attrValue = nodes3.item(i).getNodeValue();
break;
}
return attrValue;
}
public static NodeList getNodeList(Node n, String nodePath) throws XPathExpressionException {
String attrValue = null;
XPathFactory factory = XPathFactory.newInstance();
XPath xpath = factory.newXPath();
XPathExpression expr3 = xpath.compile(nodePath);
Object result3 = expr3.evaluate(n, XPathConstants.NODESET);
NodeList nodes3 = (NodeList) result3;
return nodes3;
}
public static FileObject findWadlFile(Project p) {
FileObject pf = p.getProjectDirectory();
FileObject f = pf.getFileObject("/build/web/WEB-INF/classes/com/sun/ws/rest/wadl/resource/application.wadl");
return f;
}
public static DataObject createDataObjectFromTemplate(String template,
FileObject targetFolder, String targetName,
Map parameters ) throws IOException
{
assert template != null;
assert targetFolder != null;
assert targetName != null && targetName.trim().length() > 0;
FileObject templateFO = FileUtil.getConfigFile(template);
DataObject templateDO = DataObject.find(templateFO);
DataFolder dataFolder = DataFolder.findFolder(targetFolder);
if ( parameters == null ){
return templateDO.createFromTemplate(dataFolder, targetName);
}
else {
return templateDO.createFromTemplate(dataFolder, targetName, parameters);
}
}
public static DataObject createDataObjectFromTemplate(String template,
FileObject targetFolder, String targetName) throws IOException
{
return createDataObjectFromTemplate(template, targetFolder, targetName , null );
}
public static String findStubNameFromClass(String className) {
String name = className;
int index = name.lastIndexOf(Constants.RESOURCE_SUFFIX);
if (index != -1) {
name = name.substring(0, index);
} else {
index = name.lastIndexOf(Constants.CONVERTER_SUFFIX);
if (index != -1)
name = name.substring(0, index);
}
return name;
}
public static String findUri(JavaSource rSrc) {
String path = null;
List annotations = JavaSourceHelper.getClassAnnotations(rSrc);
for (AnnotationMirror annotation : annotations) {
String cAnonType = annotation.getAnnotationType().toString();
if (RestConstants.PATH.equals(cAnonType) ) {
path = getValueFromAnnotation(annotation);
}
}
return path;
}
public static boolean isStaticResource(JavaSource src) {
List annotations = JavaSourceHelper.getClassAnnotations(src);
if (annotations != null && annotations.size() > 0) {
for (AnnotationMirror annotation : annotations) {
String classAnonType = annotation.getAnnotationType().toString();
if (RestConstants.PATH.equals(classAnonType)) {
return true;
}
}
}
return false;
}
public static boolean isConverter(JavaSource src) {
List annotations = JavaSourceHelper.getClassAnnotations(src);
if (annotations != null && annotations.size() > 0) {
for (AnnotationMirror annotation : annotations) {
String classAnonType = annotation.getAnnotationType().toString();
if (Constants.XML_ROOT_ELEMENT.equals(classAnonType)) {
return true;
}
}
}
return false;
}
public static boolean isDynamicResource(JavaSource src) {
List trees = JavaSourceHelper.getAllMethods(src);
for (MethodTree tree : trees) {
List mAnons = tree.getModifiers().getAnnotations();
if (mAnons != null && mAnons.size() > 0) {
for (AnnotationTree mAnon : mAnons) {
String mAnonType = mAnon.getAnnotationType().toString();
if (RestConstants.PATH_ANNOTATION.equals(mAnonType) || RestConstants.PATH.equals(mAnonType)) {
return true;
} else if (RestConstants.GET_ANNOTATION.equals(mAnonType) || RestConstants.GET.equals(mAnonType)) {
return true;
}
}
}
}
return false;
}
public static String findElementName(MethodTree tree) {
String eName = "";
List mAnons = tree.getModifiers().getAnnotations();
if (mAnons != null && mAnons.size() > 0) {
for (AnnotationTree mAnon : mAnons) {
eName = mAnon.toString();
if (eName.indexOf("\"") != -1) {
eName = getValueFromAnnotation(mAnon);
} else {
eName = getNameFromMethod(tree);
}
}
}
return eName.substring(0, 1).toLowerCase() + eName.substring(1);
}
public static MethodTree findGetAsXmlMethod(JavaSource rSrc) {
MethodTree method = null;
List rTrees = JavaSourceHelper.getAllMethods(rSrc);
for (MethodTree tree : rTrees) {
boolean isHttpGetMethod = false;
boolean isXmlMime = false;
List mAnons = tree.getModifiers().getAnnotations();
if (mAnons != null && mAnons.size() > 0) {
for (AnnotationTree mAnon : mAnons) {
String mAnonType = mAnon.getAnnotationType().toString();
if (RestConstants.GET_ANNOTATION.equals(mAnonType) || RestConstants.GET.equals(mAnonType)) {
isHttpGetMethod = true;
} else if (RestConstants.PRODUCE_MIME_ANNOTATION.equals(mAnonType) ||
RestConstants.PRODUCE_MIME.equals(mAnonType)) {
List mimes = getMimeAnnotationValue(mAnon);
if (mimes.contains(Constants.MimeType.JSON.value()) ||
mimes.contains(Constants.MimeType.XML.value())) {
isXmlMime = true;
}
}
}
if (isHttpGetMethod && isXmlMime) {
method = tree;
break;
}
}
}
return method;
}
public static String getNameFromMethod(MethodTree tree) {
String attrName = tree.getName().toString();
attrName = attrName.substring(attrName.indexOf("get") + 3);
attrName = attrName.substring(0, 1).toLowerCase() + attrName.substring(1);
return attrName;
}
public static String getValueFromAnnotation(AnnotationMirror annotation) {
return getValueFromAnnotation(annotation.getElementValues().values().toString());
}
public static String getValueFromAnnotation(AnnotationTree mAnon) {
return getValueFromAnnotation(mAnon.toString());
}
public static String getValueFromAnnotation(ExpressionTree eAnon) {
return getValueFromAnnotation(eAnon.toString());
}
public static String getValueFromAnnotation(String value) {
if (value.indexOf("\"") != -1) {
value = value.substring(value.indexOf("\"") + 1, value.lastIndexOf("\""));
}
return value;
}
public static List getMimeAnnotationValue(AnnotationTree ant) {
List ets = ant.getArguments();
if (ets.size() > 0) {
String value = getValueFromAnnotation(ets.get(0));
value = value.replace("\"", "");
return Arrays.asList(value.split(","));
}
return Collections.emptyList();
}
public static String escapeJSReserved(String key) {
if(key.equals("delete"))
return key + "_";
else
return key;
}
public static J2eeModule getJ2eeModule(Project prj) {
J2eeModuleProvider provider = prj.getLookup().lookup(J2eeModuleProvider.class);
if (provider != null) {
return provider.getJ2eeModule();
}
return null;
}
public static boolean isAnnotationConfigAvailable(Project project) throws IOException {
RestSupport restSupport = project.getLookup().lookup(RestSupport.class);
if ( restSupport!= null ){
if ( restSupport.hasSpringSupport()){
return false;
}
}
if (MiscUtilities.isJavaEE6AndHigher(project)) {
SourceGroup[] sourceGroups = SourceGroupSupport
.getJavaSourceGroups(project);
if (sourceGroups.length > 0) {
ClassPath cp = ClassPath.getClassPath(
sourceGroups[0].getRootFolder(), ClassPath.COMPILE);
if (cp!=null && cp.findResource(
"javax/ws/rs/ApplicationPath.class") != null // NOI18N
&& cp.findResource(
"javax/ws/rs/core/Application.class") != null)// NOI18N
{
return true;
}
}
}
return false;
}
public static boolean isJSR_311OnClasspath(Project project) throws IOException {
return hasClass( project , "javax/ws/rs/Path.class"); // NOI18N
}
public static boolean hasClass(Project project, String fqn ) throws IOException {
WebModule wm = WebModule.getWebModule(project.getProjectDirectory());
if (wm != null) {
SourceGroup[] sourceGroups = SourceGroupSupport.getJavaSourceGroups(project);
if (sourceGroups.length>0) {
ClassPath cp = ClassPath.getClassPath(sourceGroups[0].getRootFolder(),
ClassPath.COMPILE);
if (cp != null && cp.findResource(fqn) != null) {
return true;
}
}
}
return false;
}
public static FileObject createApplicationConfigClass(final RestSupport restSupport, FileObject packageFolder,
String name ) throws IOException
{
FileObject appClass = GenerationUtils.createClass(packageFolder,name, null );
JavaSource javaSource = JavaSource.forFileObject(appClass);
if ( javaSource == null ){
return null;
}
javaSource.runModificationTask( new Task(){
@Override
public void run(WorkingCopy workingCopy) throws Exception {
workingCopy.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED);
JavaSourceHelper.addClassAnnotation(workingCopy,
new String[]{"javax.ws.rs.ApplicationPath"},
new String[]{"webresources"}); // NOI18N
ClassTree tree = JavaSourceHelper.getTopLevelClassTree(workingCopy);
TreeMaker maker = workingCopy.getTreeMaker();
ClassTree newTree = maker.setExtends(tree,
maker.QualIdent(JAX_RS_APPLICATION_CLASS)); // NOI18N
ModifiersTree modifiersTree = maker.Modifiers(
EnumSet.of(Modifier.PUBLIC), Collections.singletonList(
maker.Annotation( maker.QualIdent(
Override.class.getCanonicalName()),
Collections.emptyList())));
WildcardTree wildCard = maker.Wildcard(Tree.Kind.UNBOUNDED_WILDCARD,
null);
ParameterizedTypeTree wildClass = maker.ParameterizedType(
maker.QualIdent(Class.class.getCanonicalName()),
Collections.singletonList(wildCard));
ParameterizedTypeTree wildSet = maker.ParameterizedType(
maker.QualIdent(Set.class.getCanonicalName()),
Collections.singletonList(wildClass));
MethodTree methodTree = maker.Method(modifiersTree,
RestConstants.GET_CLASSES, wildSet,
Collections.emptyList(),
Collections.emptyList(),
Collections.emptyList(),
MiscUtilities.createBodyForGetClassesMethod(restSupport), null);
newTree = maker.addClassMember(newTree, methodTree);
newTree = MiscUtilities.createAddResourceClasses(maker, newTree, workingCopy, "{}", true);
workingCopy.rewrite( tree, newTree);
}
}).commit();
return appClass;
}
public static boolean hasProfile(Project project, Profile... profiles) {
WebModule webModule = WebModule.getWebModule(project.getProjectDirectory());
if (webModule != null) {
Profile projectProfile = webModule.getJ2eeProfile();
for ( Profile profile: profiles ){
if ( projectProfile == profile ){
return true;
}
}
}
return false;
}
public static boolean hasAopAlliance(Project project) {
try {
return hasClass( project , "org/aopalliance/aop/Advice.class"); // NOI18N
}
catch(IOException e){
return false;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy