Fixed issue #50 Support for excluding certain routes from the API

minnal-example/pom.xml

@@ -59,10 +59,10 @@
 			<groupId>org.minnal</groupId>
 			<artifactId>minnal-admin</artifactId>
 		</dependency>
-		<!-- <dependency>
+		<dependency>
 			<groupId>org.minnal</groupId>
 			<artifactId>minnal-api</artifactId>
-		</dependency> -->
+		</dependency>
 		<dependency>
 			<groupId>org.activejpa</groupId>
 			<artifactId>activejpa-test</artifactId>

minnal-example/src/main/resources/log4j.properties

@@ -1,5 +1,5 @@
 #log4j.rootLogger=INFO, DEF
-log4j.rootLogger=DEBUG, stdout
+log4j.rootLogger=INFO, stdout
 
 log4j.appender.DEF=org.apache.log4j.DailyRollingFileAppender
 log4j.appender.DEF.File=log/default.log

minnal-generator/src/main/java/org/minnal/generator/test/ResourceClassTestGenerator.java

@@ -87,11 +87,19 @@ public void generate() {
 
 	private void createMethods(EntityNodePath path, StringBuffer buffer) {
 		try {
-			buffer.append(createMethod(path, true, HttpMethod.GET)).append("\n");
-			buffer.append(createMethod(path, true, HttpMethod.POST)).append("\n");
-			buffer.append(createMethod(path, false, HttpMethod.PUT)).append("\n");
-			buffer.append(createMethod(path, false, HttpMethod.GET)).append("\n");
-			buffer.append(createMethod(path, false, HttpMethod.DELETE)).append("\n");
+			if (path.isReadAllowed()) {
+				buffer.append(createMethod(path, true, HttpMethod.GET)).append("\n");
+				buffer.append(createMethod(path, false, HttpMethod.GET)).append("\n");
+			}
+			if (path.isCreateAllowed()) {
+				buffer.append(createMethod(path, true, HttpMethod.POST)).append("\n");
+			}
+			if (path.isUpdateAllowed()) {
+				buffer.append(createMethod(path, false, HttpMethod.PUT)).append("\n");
+			}
+			if (path.isDeleteAllowed()) {
+				buffer.append(createMethod(path, false, HttpMethod.DELETE)).append("\n");
+			}
 		} catch (Exception e) {
 			throw new MinnalException(e);
 		}

minnal-instrumentation/src/main/java/org/minnal/instrument/entity/AggregateRoot.java

@@ -16,4 +16,11 @@
 @Retention(RetentionPolicy.RUNTIME)
 public @interface AggregateRoot {
 
+	public boolean create() default true;
+
+	public boolean read() default true;
+
+	public boolean update() default true;
+
+	public boolean delete() default true;
 }

minnal-instrumentation/src/main/java/org/minnal/instrument/entity/EntityNode.java

@@ -21,6 +21,7 @@
 import org.minnal.instrument.entity.metadata.EntityMetaData;
 import org.minnal.instrument.entity.metadata.EntityMetaDataProvider;
 import org.minnal.instrument.entity.metadata.ParameterMetaData;
+import org.minnal.utils.reflection.ClassUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -36,6 +37,8 @@ public class EntityNode extends Node<EntityNode, EntityNodePath, EntityMetaData>
 
 	private Map<Class<?>, List<String>> visitedEntities = new HashMap<Class<?>, List<String>>();
 
+	private CollectionMetaData source;
+
 	private static final Logger logger = LoggerFactory.getLogger(EntityNode.class);
 
 	public EntityNode(Class<?> entityClass) {
@@ -48,6 +51,11 @@ public EntityNode(Class<?> entityClass, String name) {
 		this.resourceName = Inflector.tableize(name);
 	}
 
+	EntityNode(CollectionMetaData collection) {
+		this(collection.getElementType(), Inflector.singularize(collection.getName()));
+		this.source = collection;
+	}
+
 	public void construct() {
 		LinkedList<EntityNode> queue = new LinkedList<EntityNode>();
 		queue.offer(this);
@@ -59,7 +67,7 @@ public void construct() {
 				if (! collection.isEntity()) {
 					continue;
 				}
-				EntityNode child = new EntityNode(collection.getElementType(), Inflector.singularize(collection.getName()));
+				EntityNode child = new EntityNode(collection);
 				if (node.addChild(child) != null) {
 					queue.offer(child);
 				}
@@ -138,14 +146,44 @@ public class EntityNodePath extends Node<EntityNode, EntityNodePath, EntityMetaD
 
 		private String name;
 
+		private boolean createAllowed = true;
+
+		private boolean readAllowed = true;
+
+		private boolean updateAllowed = true;
+
+		private boolean deleteAllowed = true;
+
 		private List<QueryParam> queryParams = new ArrayList<QueryParam>();
 
 		public EntityNodePath(List<EntityNode> path) {
 			super(path);
 			init(path);
+			buildPath(path);
 		}
 
 		private void init(List<EntityNode> path) {
+			if (path.size() == 1) {
+				EntityMetaData data = path.get(0).getValue();
+				AggregateRoot root = ClassUtils.getAnnotation(data.getEntityClass(), AggregateRoot.class);
+				if (root != null) {
+					createAllowed = root.create();
+					readAllowed = root.read();
+					updateAllowed = root.update();
+					deleteAllowed = root.delete();
+				}
+			} else {
+				EntityNode node = path.get(size() - 1);
+				if (node.source != null) {
+					createAllowed = node.source.isCreateAllowed();
+					readAllowed = node.source.isReadAllowed();
+					updateAllowed = node.source.isUpdateAllowed();
+					deleteAllowed = node.source.isDeleteAllowed();
+				}
+			}
+		}
+
+		private void buildPath(List<EntityNode> path) {
 			StringWriter writer = new StringWriter();
 			Iterator<EntityNode> iterator = iterator();
 			String prefix = "";
@@ -216,6 +254,22 @@ public String getName() {
 		public List<QueryParam> getQueryParams() {
 			return queryParams;
 		}
+
+		public boolean isCreateAllowed() {
+			return createAllowed;
+		}
+
+		public boolean isReadAllowed() {
+			return readAllowed;
+		}
+
+		public boolean isUpdateAllowed() {
+			return updateAllowed;
+		}
+
+		public boolean isDeleteAllowed() {
+			return deleteAllowed;
+		}
 
 		@Override
 		public int hashCode() {

minnal-instrumentation/src/main/java/org/minnal/instrument/entity/metadata/CollectionMetaData.java

@@ -3,6 +3,10 @@
  */
 package org.minnal.instrument.entity.metadata;
 
+import org.minnal.instrument.entity.Collection;
+import org.minnal.utils.reflection.ClassUtils;
+
+
 /**
  * @author ganeshs
  *
@@ -15,11 +19,30 @@ public class CollectionMetaData extends MetaData {
 
 	private boolean entity;
 
-	public CollectionMetaData(String name, Class<?> elementType, Class<?> type, boolean entity) {
+	private boolean createAllowed = true;
+
+	private boolean readAllowed = true;
+
+	private boolean updateAllowed = true;
+
+	private boolean deleteAllowed = true;
+
+	public CollectionMetaData(Class<?> parent, String name, Class<?> elementType, Class<?> type, boolean entity) {
 		super(name);
 		this.elementType = elementType;
 		this.type = type;
 		this.entity = entity;
+		init(parent, name);
+	}
+
+	private void init(Class<?> parent, String property) {
+		Collection collection = ClassUtils.getAnnotation(parent, property, Collection.class);
+		if (collection != null) {
+			createAllowed = collection.create();
+			readAllowed = collection.read();
+			updateAllowed = collection.update();
+			deleteAllowed = collection.delete();
+		}
 	}
 
 	public Class<?> getElementType() {
@@ -37,6 +60,34 @@ public boolean isEntity() {
 		return entity;
 	}
 
+	/**
+	 * @return the createAllowed
+	 */
+	public boolean isCreateAllowed() {
+		return createAllowed;
+	}
+
+	/**
+	 * @return the readAllowed
+	 */
+	public boolean isReadAllowed() {
+		return readAllowed;
+	}
+
+	/**
+	 * @return the updateAllowed
+	 */
+	public boolean isUpdateAllowed() {
+		return updateAllowed;
+	}
+
+	/**
+	 * @return the deleteAllowed
+	 */
+	public boolean isDeleteAllowed() {
+		return deleteAllowed;
+	}
+
 	@Override
 	public int hashCode() {
 		final int prime = 31;

minnal-instrumentation/src/main/java/org/minnal/instrument/entity/metadata/handler/OneToManyAnnotationHandler.java

@@ -6,12 +6,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Collection;
-import java.util.Map;
 
-import javax.persistence.Entity;
 import javax.persistence.OneToMany;
 
 import org.minnal.instrument.entity.metadata.CollectionMetaData;
@@ -26,7 +21,7 @@ public class OneToManyAnnotationHandler extends AbstractAnnotationHandler {
 	@Override
 	public void handle(EntityMetaData metaData, Annotation annotation, Method method) {
 		Class<?> elementType = getElementType(method.getGenericReturnType());
-		CollectionMetaData collectionMetaData = new CollectionMetaData(getGetterName(method, false), 
+		CollectionMetaData collectionMetaData = new CollectionMetaData(metaData.getEntityClass(), getGetterName(method, false), 
 				elementType, method.getReturnType(), isEntity(elementType));
 		metaData.addCollection(collectionMetaData);
 	}
@@ -35,7 +30,7 @@ public void handle(EntityMetaData metaData, Annotation annotation, Method method
 	public void handle(EntityMetaData metaData, Annotation annotation, Field field) {
 		String name = field.getName();
 		Class<?> elementType = getElementType(field.getGenericType());
-		CollectionMetaData collectionMetaData = new CollectionMetaData(name, elementType, field.getType(), isEntity(elementType));
+		CollectionMetaData collectionMetaData = new CollectionMetaData(metaData.getEntityClass(), name, elementType, field.getType(), isEntity(elementType));
 		metaData.addCollection(collectionMetaData);
 	}