Merge 0e5f8b9 into 94fb4ef

seedstack · Sep 3, 2020 · 2ddb6ee · 2ddb6ee
2 parents 94fb4ef + 0e5f8b9
commit 2ddb6ee
Show file tree

Hide file tree

Showing 9 changed files with 431 additions and 21 deletions.
diff --git a/core/src/main/java/org/seedstack/business/internal/assembler/dsl/Context.java b/core/src/main/java/org/seedstack/business/internal/assembler/dsl/Context.java
@@ -8,37 +8,59 @@
 
 package org.seedstack.business.internal.assembler.dsl;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.lang.annotation.Annotation;
-import java.util.Set;
 import org.javatuples.Tuple;
 import org.seedstack.business.assembler.Assembler;
 import org.seedstack.business.assembler.AssemblerRegistry;
 import org.seedstack.business.domain.AggregateRoot;
 import org.seedstack.business.domain.DomainRegistry;
+import org.seedstack.business.domain.Repository;
 import org.seedstack.business.internal.BusinessErrorCode;
 import org.seedstack.business.internal.BusinessException;
 import org.seedstack.business.internal.utils.BusinessUtils;
 import org.seedstack.business.spi.DtoInfoResolver;
 
+import java.lang.annotation.Annotation;
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * Context used by the DSL to carry the internal registry and the qualifier it uses.
  */
 class Context {
     private final DomainRegistry domainRegistry;
     private final AssemblerRegistry assemblerRegistry;
     private final Set<DtoInfoResolver> dtoInfoResolvers;
+    private Annotation repoQualifier;
+    private Class<? extends Annotation> repoQualifierClass;
+    private Annotation factoryQualifier;
+    private Class<? extends Annotation> factoryQualifierClass;
     private Annotation assemblerQualifier;
     private Class<? extends Annotation> assemblerQualifierClass;
 
     public Context(DomainRegistry domainRegistry, AssemblerRegistry assemblerRegistry,
-            Set<DtoInfoResolver> dtoInfoResolvers) {
+                   Set<DtoInfoResolver> dtoInfoResolvers) {
         this.domainRegistry = domainRegistry;
         this.assemblerRegistry = assemblerRegistry;
         this.dtoInfoResolvers = dtoInfoResolvers;
     }
 
+    public void setRepoQualifier(Annotation repoQualifier) {
+        this.repoQualifier = repoQualifier;
+    }
+
+    public void setRepoQualifierClass(Class<? extends Annotation> repoQualifierClass) {
+        this.repoQualifierClass = repoQualifierClass;
+    }
+
+    public void setFactoryQualifier(Annotation factoryQualifier) {
+        this.factoryQualifier = factoryQualifier;
+    }
+
+    public void setFactoryQualifierClass(Class<? extends Annotation> factoryQualifierClass) {
+        this.factoryQualifierClass = factoryQualifierClass;
+    }
+
     void setAssemblerQualifier(Annotation assemblerQualifier) {
         this.assemblerQualifier = assemblerQualifier;
     }
@@ -52,32 +74,54 @@ <A extends AggregateRoot<I>, I, D> Assembler<A, D> assemblerOf(Class<A> aggregat
             return assemblerRegistry.getAssembler(aggregateRoot, dto, assemblerQualifierClass);
         } else if (assemblerQualifier != null) {
             return assemblerRegistry.getAssembler(aggregateRoot, dto, assemblerQualifier);
+        } else {
+            return assemblerRegistry.getAssembler(aggregateRoot, dto);
         }
-        return assemblerRegistry.getAssembler(aggregateRoot, dto);
     }
 
     <T extends Tuple, D> Assembler<T, D> tupleAssemblerOf(Class<? extends AggregateRoot<?>>[] aggregateRootTuple,
-            Class<D> dto) {
+                                                          Class<D> dto) {
         if (assemblerQualifierClass != null) {
             return assemblerRegistry.getTupleAssembler(aggregateRootTuple, dto, assemblerQualifierClass);
         } else if (assemblerQualifier != null) {
             return assemblerRegistry.getTupleAssembler(aggregateRootTuple, dto, assemblerQualifier);
+        } else {
+            return assemblerRegistry.getTupleAssembler(aggregateRootTuple, dto);
         }
-        return assemblerRegistry.getTupleAssembler(aggregateRootTuple, dto);
     }
 
     <D, A extends AggregateRoot<I>, I> A create(D dto, Class<A> aggregateClass) {
-        return findResolverFor(dto).resolveAggregate(dto, aggregateClass);
+        // TODO: implement qualifier in resolvers
+        if (factoryQualifierClass != null) {
+            throw new UnsupportedOperationException("Factory qualifiers are not supported from FluentAssembler DSL yet");
+        } else if (factoryQualifier != null) {
+            throw new UnsupportedOperationException("Factory qualifiers are not supported from FluentAssembler DSL yet");
+        } else {
+            return findResolverFor(dto).resolveAggregate(dto, aggregateClass);
+        }
     }
 
     <D, A extends AggregateRoot<?>> A create(D dto, Class<A> aggregateClass, int indexInTuple) {
-        return findResolverFor(dto).resolveAggregate(dto, aggregateClass, indexInTuple);
+        // TODO: implement qualifier in resolvers
+        if (factoryQualifierClass != null) {
+            throw new UnsupportedOperationException("Factory qualifiers are not supported from FluentAssembler DSL yet");
+        } else if (factoryQualifier != null) {
+            throw new UnsupportedOperationException("Factory qualifiers are not supported from FluentAssembler DSL yet");
+        } else {
+            return findResolverFor(dto).resolveAggregate(dto, aggregateClass, indexInTuple);
+        }
     }
 
     <A extends AggregateRoot<I>, I> A load(I id, Class<A> aggregateClass) {
-        return domainRegistry.getRepository(aggregateClass, BusinessUtils.resolveAggregateIdClass(aggregateClass))
-                .get(id)
-                .orElse(null);
+        Repository<A, I> repo;
+        if (repoQualifierClass != null) {
+            repo = domainRegistry.getRepository(aggregateClass, BusinessUtils.resolveAggregateIdClass(aggregateClass), repoQualifierClass);
+        } else if (repoQualifier != null) {
+            repo = domainRegistry.getRepository(aggregateClass, BusinessUtils.resolveAggregateIdClass(aggregateClass), repoQualifier);
+        } else {
+            repo = domainRegistry.getRepository(aggregateClass, BusinessUtils.resolveAggregateIdClass(aggregateClass));
+        }
+        return repo.get(id).orElse(null);
     }
 
     <D, I> I resolveId(D dto, Class<I> aggregateIdClass) {

diff --git a/.../seedstack/business/internal/assembler/dsl/MergeMultipleAggregatesFromRepositoryImpl.java b/.../seedstack/business/internal/assembler/dsl/MergeMultipleAggregatesFromRepositoryImpl.java
@@ -8,17 +8,19 @@
 
 package org.seedstack.business.internal.assembler.dsl;
 
-import java.util.stream.Stream;
+import com.google.inject.name.Names;
 import org.seedstack.business.assembler.dsl.MergeAs;
 import org.seedstack.business.assembler.dsl.MergeFromRepository;
 import org.seedstack.business.assembler.dsl.MergeFromRepositoryOrFactory;
 import org.seedstack.business.domain.AggregateNotFoundException;
 import org.seedstack.business.domain.AggregateRoot;
 import org.seedstack.business.internal.utils.BusinessUtils;
 
+import java.lang.annotation.Annotation;
+import java.util.stream.Stream;
+
 class MergeMultipleAggregatesFromRepositoryImpl<A extends AggregateRoot<I>, I, D> implements
         MergeFromRepository<MergeAs<A>>, MergeFromRepositoryOrFactory<MergeAs<A>> {
-
     private final Context context;
     private final Class<A> aggregateClass;
     private final Class<I> aggregateClassId;
@@ -36,6 +38,24 @@ public MergeFromRepositoryOrFactory<MergeAs<A>> fromRepository() {
         return this;
     }
 
+    @Override
+    public MergeFromRepositoryOrFactory<MergeAs<A>> fromRepository(Annotation qualifier) {
+        this.context.setRepoQualifier(qualifier);
+        return this;
+    }
+
+    @Override
+    public MergeFromRepositoryOrFactory<MergeAs<A>> fromRepository(String qualifier) {
+        this.context.setRepoQualifier(Names.named(qualifier));
+        return this;
+    }
+
+    @Override
+    public MergeFromRepositoryOrFactory<MergeAs<A>> fromRepository(Class<? extends Annotation> qualifier) {
+        this.context.setRepoQualifierClass(qualifier);
+        return this;
+    }
+
     @Override
     public MergeAs<A> fromFactory() {
         return new MergeAsImpl<>(dtoStream.map(dto -> {
@@ -45,6 +65,24 @@ public MergeAs<A> fromFactory() {
         }));
     }
 
+    @Override
+    public MergeAs<A> fromFactory(Annotation qualifier) {
+        this.context.setFactoryQualifier(qualifier);
+        return fromFactory();
+    }
+
+    @Override
+    public MergeAs<A> fromFactory(String qualifier) {
+        this.context.setFactoryQualifier(Names.named(qualifier));
+        return fromFactory();
+    }
+
+    @Override
+    public MergeAs<A> fromFactory(Class<? extends Annotation> qualifier) {
+        this.context.setFactoryQualifierClass(qualifier);
+        return fromFactory();
+    }
+
     @Override
     public MergeAs<A> orFail() throws AggregateNotFoundException {
         return new MergeAsImpl<>(dtoStream.map(dto -> {
@@ -70,4 +108,22 @@ public MergeAs<A> orFromFactory() {
             return a;
         }));
     }
+
+    @Override
+    public MergeAs<A> orFromFactory(Annotation qualifier) {
+        this.context.setFactoryQualifier(qualifier);
+        return orFromFactory();
+    }
+
+    @Override
+    public MergeAs<A> orFromFactory(String qualifier) {
+        this.context.setFactoryQualifier(Names.named(qualifier));
+        return orFromFactory();
+    }
+
+    @Override
+    public MergeAs<A> orFromFactory(Class<? extends Annotation> qualifier) {
+        this.context.setFactoryQualifierClass(qualifier);
+        return orFromFactory();
+    }
 }
diff --git a/.../org/seedstack/business/internal/assembler/dsl/MergeMultipleTuplesFromRepositoryImpl.java b/.../org/seedstack/business/internal/assembler/dsl/MergeMultipleTuplesFromRepositoryImpl.java
@@ -8,9 +8,7 @@
 
 package org.seedstack.business.internal.assembler.dsl;
 
-import static org.seedstack.business.internal.utils.BusinessUtils.getAggregateIdClasses;
-
-import java.util.stream.Stream;
+import com.google.inject.name.Names;
 import org.javatuples.Tuple;
 import org.seedstack.business.assembler.dsl.MergeAs;
 import org.seedstack.business.assembler.dsl.MergeFromRepository;
@@ -19,6 +17,11 @@
 import org.seedstack.business.domain.AggregateRoot;
 import org.seedstack.business.util.Tuples;
 
+import java.lang.annotation.Annotation;
+import java.util.stream.Stream;
+
+import static org.seedstack.business.internal.utils.BusinessUtils.getAggregateIdClasses;
+
 class MergeMultipleTuplesFromRepositoryImpl<T extends Tuple, D> implements MergeFromRepository<MergeAs<T>>,
         MergeFromRepositoryOrFactory<MergeAs<T>> {
 
@@ -41,6 +44,24 @@ public MergeFromRepositoryOrFactory<MergeAs<T>> fromRepository() {
         return this;
     }
 
+    @Override
+    public MergeFromRepositoryOrFactory<MergeAs<T>> fromRepository(Annotation qualifier) {
+        this.context.setRepoQualifier(qualifier);
+        return this;
+    }
+
+    @Override
+    public MergeFromRepositoryOrFactory<MergeAs<T>> fromRepository(String qualifier) {
+        this.context.setRepoQualifier(Names.named(qualifier));
+        return this;
+    }
+
+    @Override
+    public MergeFromRepositoryOrFactory<MergeAs<T>> fromRepository(Class<? extends Annotation> qualifier) {
+        this.context.setRepoQualifierClass(qualifier);
+        return this;
+    }
+
     @Override
     public MergeAs<T> fromFactory() {
         return new MergeAsImpl<>(dtoStream.map(dto -> {
@@ -54,6 +75,24 @@ public MergeAs<T> fromFactory() {
         }));
     }
 
+    @Override
+    public MergeAs<T> fromFactory(Annotation qualifier) {
+        this.context.setFactoryQualifier(qualifier);
+        return fromFactory();
+    }
+
+    @Override
+    public MergeAs<T> fromFactory(String qualifier) {
+        this.context.setFactoryQualifier(Names.named(qualifier));
+        return fromFactory();
+    }
+
+    @Override
+    public MergeAs<T> fromFactory(Class<? extends Annotation> qualifier) {
+        this.context.setFactoryQualifierClass(qualifier);
+        return fromFactory();
+    }
+
     @Override
     public MergeAs<T> orFail() throws AggregateNotFoundException {
         return new MergeAsImpl<>(dtoStream.map(dto -> {
@@ -88,8 +127,26 @@ public MergeAs<T> orFromFactory() {
         }));
     }
 
+    @Override
+    public MergeAs<T> orFromFactory(Annotation qualifier) {
+        this.context.setFactoryQualifier(qualifier);
+        return orFromFactory();
+    }
+
+    @Override
+    public MergeAs<T> orFromFactory(String qualifier) {
+        this.context.setFactoryQualifier(Names.named(qualifier));
+        return orFromFactory();
+    }
+
+    @Override
+    public MergeAs<T> orFromFactory(Class<? extends Annotation> qualifier) {
+        this.context.setFactoryQualifierClass(qualifier);
+        return orFromFactory();
+    }
+
     @SuppressWarnings("unchecked")
-    private <A extends AggregateRoot<I>, I> AggregateRoot<?> load(Object id,
+    private <A extends AggregateRoot<I>, I> A load(Object id,
             Class<? extends AggregateRoot<?>> aggregateClass) {
         return context.load((I) id, (Class<A>) aggregateClass);
     }