supporting ids of any type

caelum · Mar 22, 2011 · adde295 · adde295
1 parent d47fedd
commit adde295
Show file tree

Hide file tree

Showing 5 changed files with 68 additions and 18 deletions.
diff --git a/vraptor-core/src/main/java/br/com/caelum/vraptor/core/Converters.java b/vraptor-core/src/main/java/br/com/caelum/vraptor/core/Converters.java
@@ -36,7 +36,7 @@ public interface Converters {
 	 * @param container
 	 * @return
 	 */
-	Converter<?> to(Class<?> type);
+	<T> Converter<T> to(Class<T> type);
 
 	void register(Class<? extends Converter<?>> converterClass);
 

diff --git a/vraptor-core/src/main/java/br/com/caelum/vraptor/core/DefaultConverters.java b/vraptor-core/src/main/java/br/com/caelum/vraptor/core/DefaultConverters.java
@@ -54,11 +54,11 @@ public void register(Class<? extends Converter<?>> converterClass) {
 		classes.addFirst(converterClass);
     }
 
-    public Converter<?> to(Class<?> clazz) {
+    public <T> Converter<T> to(Class<T> clazz) {
         if (!existsFor(clazz)) {
 			throw new VRaptorException("Unable to find converter for " + clazz.getName());
 		}
-        return container.instanceFor(findConverterType(clazz));
+        return (Converter<T>) container.instanceFor(findConverterType(clazz));
     }
 
 	private Class<? extends Converter<?>> findConverterType(Class<?> clazz) {

diff --git a/.../src/main/java/br/com/caelum/vraptor/util/hibernate/extra/ParameterLoaderInterceptor.java b/.../src/main/java/br/com/caelum/vraptor/util/hibernate/extra/ParameterLoaderInterceptor.java
@@ -5,29 +5,37 @@
 import static com.google.common.collect.Iterables.isEmpty;
 import static java.util.Arrays.asList;
 
+import java.io.Serializable;
 import java.lang.annotation.Annotation;
 
 import javax.servlet.http.HttpServletRequest;
 
+import net.vidageek.mirror.dsl.Mirror;
+
 import org.hibernate.Session;
 
+import br.com.caelum.vraptor.Converter;
 import br.com.caelum.vraptor.InterceptionException;
 import br.com.caelum.vraptor.Intercepts;
 import br.com.caelum.vraptor.Lazy;
 import br.com.caelum.vraptor.Result;
+import br.com.caelum.vraptor.core.Converters;
 import br.com.caelum.vraptor.core.InterceptorStack;
+import br.com.caelum.vraptor.core.Localization;
 import br.com.caelum.vraptor.http.ParameterNameProvider;
 import br.com.caelum.vraptor.interceptor.Interceptor;
 import br.com.caelum.vraptor.interceptor.ParametersInstantiatorInterceptor;
 import br.com.caelum.vraptor.resource.ResourceMethod;
 
+import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 
 /**
- *
+ * Interceptor that loads given entity from the database.
  *
  * @author Lucas Cavalcanti
- * @since
+ * @author Cecilia Fernandes
+ * @since 3.3.2
  *
  */
 @Intercepts(before=ParametersInstantiatorInterceptor.class)
@@ -38,21 +46,21 @@ public class ParameterLoaderInterceptor implements Interceptor {
 	private final HttpServletRequest request;
 	private final ParameterNameProvider provider;
 	private final Result result;
+	private final Converters converters;
+	private final Localization localization;
 
-	public ParameterLoaderInterceptor(Session session, HttpServletRequest request, ParameterNameProvider provider, Result result) {
+	public ParameterLoaderInterceptor(Session session, HttpServletRequest request, ParameterNameProvider provider,
+			Result result, Converters converters, Localization localization) {
 		this.session = session;
 		this.request = request;
 		this.provider = provider;
 		this.result = result;
+		this.converters = converters;
+		this.localization = localization;
 	}
 
 	public boolean accepts(ResourceMethod method) {
-		for (Annotation[] param : method.getMethod().getParameterAnnotations()) {
-			if (any(asList(param), instanceOf(Load.class))) {
-				return true;
-			}
-		}
-		return false;
+		return any(asList(method.getMethod().getParameterAnnotations()), hasLoadAnnotation());
 	}
 
 	public void intercept(InterceptorStack stack, ResourceMethod method, Object resourceInstance)
@@ -80,13 +88,25 @@ public void intercept(InterceptorStack stack, ResourceMethod method, Object reso
 		stack.next(method, resourceInstance);
 	}
 
-	private Object load(String name, Class<?> types) {
+	private Object load(String name, Class type) {
 		String parameter = request.getParameter(name + ".id");
 		if (parameter == null) {
 			return null;
 		}
-		Long id = Long.valueOf(parameter);
-		return session.get(types, id);
+		Class<?> idType = new Mirror().on(type).reflect().field("id").getType();
+		Converter<?> converter = converters.to(idType);
+
+		Serializable id = (Serializable) converter.convert(parameter, type, localization.getBundle());
+		return session.get(type, id);
 	}
 
+	private Predicate<Annotation[]> hasLoadAnnotation() {
+		return new Predicate<Annotation[]>() {
+			public boolean apply(Annotation[] param) {
+				return any(asList(param), instanceOf(Load.class));
+			}
+		};
+	}
+
+
 }
diff --git a/vraptor-core/src/main/java/br/com/caelum/vraptor/vraptor2/VRaptor2Converters.java b/vraptor-core/src/main/java/br/com/caelum/vraptor/vraptor2/VRaptor2Converters.java
@@ -59,9 +59,9 @@ void setDelegateConverters(Converters delegateConverters) {
 		this.delegateConverters = delegateConverters;
 	}
 
-	public Converter<?> to(Class<?> type) {
+	public <T> Converter<T> to(Class<T> type) {
 		Converter<?> vraptor2Convterter = findVRaptor2Converter(type);
-		return vraptor2Convterter == null ? delegateConverters.to(type) : vraptor2Convterter;
+		return (Converter<T>) (vraptor2Convterter == null ? delegateConverters.to(type) : vraptor2Convterter);
 	}
 
 	private Converter<?> findVRaptor2Converter(Class<?> type) {

diff --git a/.../test/java/br/com/caelum/vraptor/util/hibernate/extra/ParameterLoaderInterceptorTest.java b/.../test/java/br/com/caelum/vraptor/util/hibernate/extra/ParameterLoaderInterceptorTest.java
@@ -15,10 +15,14 @@
 import org.mockito.MockitoAnnotations;
 
 import br.com.caelum.vraptor.Result;
+import br.com.caelum.vraptor.converter.LongConverter;
+import br.com.caelum.vraptor.converter.StringConverter;
+import br.com.caelum.vraptor.core.Converters;
 import br.com.caelum.vraptor.core.InterceptorStack;
 import br.com.caelum.vraptor.http.ParameterNameProvider;
 import br.com.caelum.vraptor.resource.DefaultResourceMethod;
 import br.com.caelum.vraptor.resource.ResourceMethod;
+import br.com.caelum.vraptor.util.test.MockLocalization;
 
 public class ParameterLoaderInterceptorTest {
 
@@ -27,18 +31,25 @@ public class ParameterLoaderInterceptorTest {
 	private @Mock HttpServletRequest request;
 	private @Mock ParameterNameProvider provider;
 	private @Mock Result result;
+	private @Mock Converters converters;
+
 	private ParameterLoaderInterceptor interceptor;
 	private ResourceMethod method;
 	private @Mock InterceptorStack stack;
 	private Object instance;
 	private ResourceMethod managed;
+	private ResourceMethod other;
 
 	@Before
 	public void setUp() throws Exception {
 		MockitoAnnotations.initMocks(this);
-		interceptor = new ParameterLoaderInterceptor(session, request, provider, result);
+		interceptor = new ParameterLoaderInterceptor(session, request, provider, result, converters, new MockLocalization());
 		method = DefaultResourceMethod.instanceFor(Resource.class, Resource.class.getMethod("method", Entity.class));
 		managed = DefaultResourceMethod.instanceFor(Resource.class, Resource.class.getMethod("managed", Entity.class));
+		other = DefaultResourceMethod.instanceFor(Resource.class, Resource.class.getMethod("other", OtherEntity.class));
+
+		when(converters.to(Long.class)).thenReturn(new LongConverter());
+		when(converters.to(String.class)).thenReturn(new StringConverter());
 	}
 
 	@Test
@@ -55,6 +66,20 @@ public void shouldLoadEntityUsingId() throws Exception {
 		verify(stack).next(method, instance);
 	}
 
+	@Test
+	public void shouldLoadEntityUsingIdOfAnyType() throws Exception {
+		when(provider.parameterNamesFor(other.getMethod())).thenReturn(new String[] {"entity"});
+		when(request.getParameter("entity.id")).thenReturn("123");
+		OtherEntity expectedEntity = new OtherEntity();
+		when(session.get(OtherEntity.class, "123")).thenReturn(expectedEntity);
+
+		interceptor.intercept(stack, other, instance);
+
+		verify(request).setAttribute("entity", expectedEntity);
+		verify(session).evict(expectedEntity);
+		verify(stack).next(other, instance);
+	}
+
 	@Test
 	public void shouldNotEvictIfIsManaged() throws Exception {
 		when(provider.parameterNamesFor(managed.getMethod())).thenReturn(new String[] {"entity"});
@@ -97,10 +122,15 @@ public void shouldSend404WhenIdDoesntExist() throws Exception {
 	static class Entity {
 		private Long id;
 	}
+	static class OtherEntity {
+		private String id;
+	}
 
 	static class Resource {
 		public void method(@Load Entity entity) {
 		}
+		public void other(@Load OtherEntity entity) {
+		}
 		public void managed(@Load(managed=true) Entity entity) {
 		}
 	}