changes default dynamic return

eclipse · Feb 21, 2019 · 41f50a4 · 41f50a4
1 parent dad530a
commit 41f50a4
Show file tree

Hide file tree

Showing 3 changed files with 37 additions and 114 deletions.
diff --git a/...s-column/src/main/java/org/jnosql/artemis/column/query/AbstractColumnRepositoryProxy.java b/...s-column/src/main/java/org/jnosql/artemis/column/query/AbstractColumnRepositoryProxy.java
@@ -21,13 +21,17 @@
 import org.jnosql.artemis.Repository;
 import org.jnosql.artemis.column.ColumnTemplate;
 import org.jnosql.artemis.query.RepositoryType;
+import org.jnosql.artemis.reflection.DefaultDynamicReturn;
+import org.jnosql.artemis.reflection.DynamicReturnConverter;
 import org.jnosql.diana.api.column.ColumnDeleteQuery;
 import org.jnosql.diana.api.column.ColumnQuery;
 
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import java.util.function.Supplier;
 
 import static org.jnosql.artemis.column.query.ReturnTypeConverterUtil.returnObject;
 import static org.jnosql.diana.api.column.query.ColumnQueryBuilder.select;
@@ -46,6 +50,9 @@ public abstract class AbstractColumnRepositoryProxy<T, ID> extends  BaseColumnRe
 
     protected abstract Converters getConverters();
 
+    private final DynamicReturnConverter returnConverter = DynamicReturnConverter.INSTANCE;
+
+
     @Override
     public Object invoke(Object instance, Method method, Object[] args) throws Throwable {
         RepositoryType type = RepositoryType.of(method);
@@ -56,7 +63,12 @@ public Object invoke(Object instance, Method method, Object[] args) throws Throw
                 return method.invoke(getRepository(), args);
             case FIND_BY:
                 ColumnQuery query = getQuery(method, args);
-                return returnObject(query, getTemplate(), typeClass, method);
+                DefaultDynamicReturn<?> dynamicReturn = DefaultDynamicReturn.builder()
+                        .withClassSource(typeClass)
+                        .withMethodSource(method).withList(() -> getTemplate().select(query))
+                        .withSingleResult(() -> getTemplate().singleResult(query)).build();
+
+                return returnConverter.convert(dynamicReturn);
             case FIND_ALL:
                 return returnObject(select().from(getClassMapping().getName()).build(),
                         getTemplate(), typeClass, method);
@@ -85,6 +97,15 @@ private Object getJnosqlQuery(Method method, Object[] args, Class<?> typeClass)
             params.forEach(prepare::bind);
             entities = prepare.getResultList();
         }
+
+        Supplier<List<?>> listSupplier = () -> entities;
+        Supplier<Optional<?>> singleSupplier = DefaultDynamicReturn.toSingleResult(method).
+        DefaultDynamicReturn<?> dynamicReturn = DefaultDynamicReturn.builder()
+                .withClassSource(typeClass)
+                .withMethodSource(method)
+                .withList(listSupplier)
+                .withSingleResult(() -> ).build();
+
         return ReturnTypeConverterUtil.returnObject(entities, typeClass, method);
     }
 

diff --git a/...artemis-column/src/main/java/org/jnosql/artemis/column/query/ReturnTypeConverterUtil.java b/...artemis-column/src/main/java/org/jnosql/artemis/column/query/ReturnTypeConverterUtil.java
diff --git a/mapping/artemis-core/src/main/java/org/jnosql/artemis/reflection/DefaultDynamicReturn.java b/mapping/artemis-core/src/main/java/org/jnosql/artemis/reflection/DefaultDynamicReturn.java
@@ -40,14 +40,14 @@ public class DefaultDynamicReturn<T> implements DynamicReturn {
      * @param <T>    the return type
      * @return the function that does this conversion
      */
-    public static <T> Function<Supplier<List<T>>, Optional<T>> toSingleResult(final Method method) {
+    public static <T> Function<Supplier<List<T>>, Supplier<Optional<T>>> toSingleResult(final Method method) {
         return l -> {
             List<T> entities = l.get();
             if (entities.isEmpty()) {
-                return Optional.empty();
+                return () -> Optional.empty();
             }
             if (entities.size() == 1) {
-                return Optional.ofNullable(entities.get(0));
+                return () -> Optional.ofNullable(entities.get(0));
             }
             throw new NonUniqueResultException("No unique result to the method: " + method);
         };
@@ -98,44 +98,43 @@ public List<T> list() {
      * @param <T> the type
      * @return a builder instance
      */
-    public static <T> DefaultDynamicReturnBuilder<T> builder() {
-        return new DefaultDynamicReturnBuilder<>();
+    public static <T> DefaultDynamicReturnBuilder builder() {
+        return new DefaultDynamicReturnBuilder();
     }
 
     /**
      * A builder of {@link DefaultDynamicReturn}
      *
-     * @param <T> the source type
      */
-    public static class DefaultDynamicReturnBuilder<T> {
+    public static class DefaultDynamicReturnBuilder {
 
-        private Class<T> classSource;
+        private Class<?> classSource;
 
         private Method methodSource;
 
-        private Supplier<Optional<T>> singleResult;
+        private Supplier<Optional<?>> singleResult;
 
-        private Supplier<List<T>> list;
+        private Supplier<List<?>> list;
 
         private DefaultDynamicReturnBuilder() {
         }
 
-        public DefaultDynamicReturnBuilder<T> withClassSource(Class<T> classSource) {
-            this.classSource = classSource;
+        public DefaultDynamicReturnBuilder withClassSource(Class<?> classSource) {
+            this.classSource =  classSource;
             return this;
         }
 
-        public DefaultDynamicReturnBuilder<T> withMethodSource(Method methodSource) {
+        public DefaultDynamicReturnBuilder withMethodSource(Method methodSource) {
             this.methodSource = methodSource;
             return this;
         }
 
-        public DefaultDynamicReturnBuilder<T> withSingleResult(Supplier<Optional<T>> singleResult) {
+        public DefaultDynamicReturnBuilder withSingleResult(Supplier<Optional<?>> singleResult) {
             this.singleResult = singleResult;
             return this;
         }
 
-        public DefaultDynamicReturnBuilder<T> withList(Supplier<List<T>> list) {
+        public DefaultDynamicReturnBuilder withList(Supplier<List<?>> list) {
             this.list = list;
             return this;
         }
@@ -152,7 +151,7 @@ public DefaultDynamicReturn build() {
             requireNonNull(singleResult, "the single result supplier is required");
             requireNonNull(list, "the list result supplier is required");
 
-            return new DefaultDynamicReturn<>(classSource, methodSource, singleResult, list);
+            return new DefaultDynamicReturn(classSource, methodSource, singleResult, list);
         }
     }