index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/AbstractArangoOneValueFilterOprionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperatorStatement;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlRootNode;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlVariable;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlQuestionMarkOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.GraphLoaderReturnType;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AbstractOneValueFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.arangodb.internal.DocumentFields;
import java.util.HashMap;
import org.jetbrains.annotations.NotNull;
public abstract class AbstractArangoOneValueFilterOprionResolver<F extends FilterOption<?>>
extends AbstractArangoSearchOptionResolver<F> {
protected AbstractArangoOneValueFilterOprionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOGMFactory
);
}
@NotNull
protected ArangoQuery getArangoQuery(
AbstractOneValueFilterOption<?> option,
ArangoSearchResolvingContext context,
Object decoratedValue,
AqlOperator aqlOperator
) {
var attributeTypePlaceholder = this.createAttributeNamePlaceholder(
context,
option.getOptionType()
);
var attributeValuePlaceholder = this.createAttributeValuePlaceholder(
context,
option.getOptionType()
);
var bindParameters = new HashMap<String, Object>();
bindParameters.put(attributeValuePlaceholder, decoratedValue);
var rightExpression = new AqlVariable(attributeValuePlaceholder).markAsBindParameter();
if (option.isLeaf()) {
if (option.isDescribingAttribute()) {
var attributeName = option.getParameters().getAttributeName();
bindParameters.put(attributeTypePlaceholder, attributeName);
var filter = new AqlOperatorStatement(
this.getAttributeValue(context, attributeTypePlaceholder, attributeName),
aqlOperator,
rightExpression
);
return new ArangoQuery(filter, bindParameters);
} else {
var filter = new AqlOperatorStatement(
context.getDocumentName().getField(DocumentFields.KEY),
aqlOperator,
rightExpression
);
return new ArangoQuery(filter, bindParameters);
}
}
var searchOptionSubQueryPostfix = this.createSearchOptionSubQueryPostfix(
context,
option.getOptionType()
);
var searchOptionSubQuery = this.createSearchOptionSubQuery(
option.getParameters().getAttributeNamePath(),
context,
searchOptionSubQueryPostfix,
GraphLoaderReturnType.FILTER_OPTION
);
bindParameters.putAll(searchOptionSubQuery.getBindParameters());
var searchOptionSubQueryAqlNode = searchOptionSubQuery.getAqlNode();
if (searchOptionSubQueryAqlNode instanceof AqlRootNode rootNode) {
var questionMarkOperator = rootNode.getAqlNodeList().stream()
.filter(AqlQuestionMarkOperator.class::isInstance)
.map(AqlQuestionMarkOperator.class::cast)
.findFirst();
if (questionMarkOperator.isPresent()) {
questionMarkOperator.get().setDeepestRightHandExpression(
new AqlRootNode(
aqlOperator,
rightExpression
)
);
return new ArangoQuery(
searchOptionSubQueryAqlNode,
bindParameters
);
}
}
return new ArangoQuery(
new AqlOperatorStatement(
searchOptionSubQuery.getAqlNode(),
aqlOperator,
rightExpression
),
bindParameters
);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/AbstractArangoSearchOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQueryType;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlNode;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlRootNode;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlVariable;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlParentheses;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlQuestionMarkOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoGraphTraversalSubQueryBuilder;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoQueryByNodeTypeBuilder;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.arangograph.graphLoader.arangoQuery.exceptions.CannotBuildArangoQuery;
import ai.stapi.graphoperations.graphLanguage.graphDescription.GraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLoader.GraphLoaderReturnType;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.AbstractSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.serializableGraph.GraphElementKeys;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
import org.jetbrains.annotations.NotNull;
public abstract class AbstractArangoSearchOptionResolver<S extends SearchOption<?>>
extends AbstractSearchOptionResolver<S, ArangoSearchResolvingContext, ArangoQuery> {
protected final ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver;
protected final GenericSubQueryResolver genericSubQueryResolver;
protected final GraphLoaderOgmFactory graphLoaderOGMFactory;
protected AbstractArangoSearchOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(structureSchemaFinder);
this.arangoGenericSearchOptionResolver = arangoGenericSearchOptionResolver;
this.genericSubQueryResolver = genericSubQueryResolver;
this.graphLoaderOGMFactory = graphLoaderOGMFactory;
}
@NotNull
protected String createAttributeNamePlaceholder(ArangoSearchResolvingContext context,
String optionType) {
if (context.getSubQueryPostfix().isBlank()) {
return String.format("%sAttributeNamePlaceholder_%s", optionType,
context.getPlaceholderPostfix());
}
return String.format(
"%sAttributeNamePlaceholder_%s__%s",
optionType,
context.getPlaceholderPostfix(),
context.getSubQueryPostfix()
);
}
@NotNull
protected String createSearchOptionSubQueryPostfix(ArangoSearchResolvingContext context,
String optionType) {
if (context.getSubQueryPostfix().isBlank()) {
return String.format("%sOption_%s", optionType, context.getPlaceholderPostfix());
}
return String.format(
"%sOption_%s__%s",
optionType,
context.getPlaceholderPostfix(),
context.getSubQueryPostfix()
);
}
protected String createAttributeValuePlaceholder(ArangoSearchResolvingContext context,
String optionType) {
if (context.getSubQueryPostfix().isBlank()) {
return String.format("%sAttributeValuePlaceholder_%s", optionType,
context.getPlaceholderPostfix());
}
return String.format(
"%sAttributeValuePlaceholder_%s__%s",
optionType,
context.getPlaceholderPostfix(),
context.getSubQueryPostfix()
);
}
protected AqlVariable getFirstAttributeValue(
ArangoSearchResolvingContext context,
String attributeTypePlaceholder
) {
return context.getDocumentName()
.getField(GraphElementKeys.ATTRIBUTES)
.getField("@" + attributeTypePlaceholder)
.getItem(0)
.getField("values")
.getItem(0)
.getField("value");
}
protected AqlNode getAttributeValue(
ArangoSearchResolvingContext context,
String attributeTypePlaceholder,
String attributeName
) {
var values = context.getDocumentName()
.getField(GraphElementKeys.ATTRIBUTES)
.getField("@" + attributeTypePlaceholder)
.getItem(0)
.getField("values");
var fieldDefinition = this.structureSchemaFinder.getFieldDefinitionOrFallback(
context.getGraphElementType(),
attributeName
);
if (fieldDefinition.isList()) {
return new AqlParentheses(values.getAllItems().getField("value"));
} else {
return values.getItem(0).getField("value");
}
}
protected ArangoQuery createSearchOptionSubQuery(
GraphDescription attributeNamePath,
ArangoSearchResolvingContext context,
String searchOptionSubQueryPostfix,
GraphLoaderReturnType returnType
) {
var originQueryType = context.getOriginQueryType();
var relationshipStructureSchema = this.createRelationshipStructureSchema(
attributeNamePath,
context.getGraphElementType()
);
if (originQueryType.equals(ArangoQueryType.NODE)) {
var graphTraversalBuilder = ArangoGraphTraversalSubQueryBuilder.asConnections(
this.arangoGenericSearchOptionResolver,
this.structureSchemaFinder,
(AbstractEdgeDescription) attributeNamePath,
searchOptionSubQueryPostfix,
context.getDocumentName()
);
this.genericSubQueryResolver.resolve(graphTraversalBuilder, attributeNamePath);
var subQuery = graphTraversalBuilder.build(returnType);
var aqlParentheses = new AqlParentheses(subQuery.getAqlNode());
if (returnType.equals(GraphLoaderReturnType.SORT_OPTION)) {
return new ArangoQuery(
aqlParentheses.getItem(0),
subQuery.getBindParameters()
);
} else {
AqlQuestionMarkOperator aqlQuestionMarkOperator = null;
for (var relationshipSchema : relationshipStructureSchema) {
if (relationshipSchema.fieldDefinition().isList()) {
if (aqlQuestionMarkOperator != null) {
aqlQuestionMarkOperator.setDeepestRightHandExpression(
new AqlQuestionMarkOperator(
null,
new AqlOperator(relationshipSchema.operator().name())
)
);
} else {
aqlQuestionMarkOperator = new AqlQuestionMarkOperator(
null,
new AqlOperator(relationshipSchema.operator().name())
);
}
}
}
AqlNode finalParentheses = aqlParentheses;
if (!relationshipStructureSchema.isEmpty()) {
var first = relationshipStructureSchema.get(0);
if (!first.fieldDefinition().isList()) {
finalParentheses = finalParentheses.getItem(0);
}
}
return new ArangoQuery(
aqlQuestionMarkOperator == null ? finalParentheses
: new AqlRootNode(finalParentheses, aqlQuestionMarkOperator),
subQuery.getBindParameters()
);
}
}
if (
List.of(
ArangoQueryType.OUTGOING_EDGE,
ArangoQueryType.INGOING_EDGE
).contains(originQueryType)
) {
var nodeDocument = originQueryType.equals(ArangoQueryType.OUTGOING_EDGE) ?
context.getDocumentName().getField("_to") :
context.getDocumentName().getField("_from");
var queryByNodeByTypeBuilder = new ArangoQueryByNodeTypeBuilder(
this.arangoGenericSearchOptionResolver,
this.structureSchemaFinder,
searchOptionSubQueryPostfix,
nodeDocument
);
var nodeDescriptionParameters = (NodeDescriptionParameters) attributeNamePath.getParameters();
var nodeGetOption = queryByNodeByTypeBuilder.addGetNodeOption(
nodeDescriptionParameters.getNodeType()
);
this.genericSubQueryResolver.resolve(nodeGetOption, attributeNamePath);
var subQuery = queryByNodeByTypeBuilder.build(returnType);
var aqlParentheses = new AqlParentheses(subQuery.getAqlNode()).getItem(0);
if (returnType.equals(GraphLoaderReturnType.SORT_OPTION)) {
return new ArangoQuery(
aqlParentheses,
subQuery.getBindParameters()
);
} else {
AqlQuestionMarkOperator aqlQuestionMarkOperator = null;
for (var relationshipSchema : relationshipStructureSchema) {
if (relationshipSchema.fieldDefinition().isList()) {
if (aqlQuestionMarkOperator != null) {
aqlQuestionMarkOperator.setDeepestRightHandExpression(
new AqlQuestionMarkOperator(
null,
new AqlOperator(relationshipSchema.operator().name())
)
);
} else {
aqlQuestionMarkOperator = new AqlQuestionMarkOperator(
null,
new AqlOperator(relationshipSchema.operator().name())
);
}
}
}
return new ArangoQuery(
aqlQuestionMarkOperator == null ? aqlParentheses
: new AqlRootNode(aqlParentheses, aqlQuestionMarkOperator),
subQuery.getBindParameters()
);
}
}
if (originQueryType.equals(ArangoQueryType.GRAPH_TRAVERSAL)) {
var graphTraversalBuilder = ArangoGraphTraversalSubQueryBuilder.asConnections(
this.arangoGenericSearchOptionResolver,
this.structureSchemaFinder,
(AbstractEdgeDescription) attributeNamePath,
searchOptionSubQueryPostfix,
context.getDocumentName()
);
this.genericSubQueryResolver.resolve(graphTraversalBuilder, attributeNamePath);
var subQuery = graphTraversalBuilder.build(returnType);
var aqlParentheses = new AqlParentheses(subQuery.getAqlNode());
if (returnType.equals(GraphLoaderReturnType.SORT_OPTION)) {
return new ArangoQuery(
aqlParentheses.getItem(0),
subQuery.getBindParameters()
);
} else {
AqlQuestionMarkOperator aqlQuestionMarkOperator = null;
for (var relationshipSchema : relationshipStructureSchema) {
if (relationshipSchema.fieldDefinition().isList()) {
if (aqlQuestionMarkOperator != null) {
aqlQuestionMarkOperator.setDeepestRightHandExpression(
new AqlQuestionMarkOperator(
null,
new AqlOperator(relationshipSchema.operator().name())
)
);
} else {
aqlQuestionMarkOperator = new AqlQuestionMarkOperator(
null,
new AqlOperator(relationshipSchema.operator().name())
);
}
}
}
AqlNode finalParentheses = aqlParentheses;
if (!relationshipStructureSchema.isEmpty()) {
var first = relationshipStructureSchema.get(0);
if (!first.fieldDefinition().isList()) {
finalParentheses = finalParentheses.getItem(0);
}
}
return new ArangoQuery(
aqlQuestionMarkOperator == null ? finalParentheses
: new AqlRootNode(finalParentheses, aqlQuestionMarkOperator),
subQuery.getBindParameters()
);
}
}
throw CannotBuildArangoQuery.becauseEncounteredNonExisitingOriginQueryType(originQueryType);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoAllMatchFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperatorStatement;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlRootNode;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlParentheses;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlQuestionMarkOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.CollectionComparisonOperator;
import ai.stapi.graphoperations.graphLoader.search.GenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.SearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AllMatchFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
import java.util.Objects;
public class ArangoAllMatchFilterOptionResolver
extends AbstractArangoCompositeFilterOptionResolver<AllMatchFilterOption> {
public ArangoAllMatchFilterOptionResolver(
StructureSchemaFinder structureSchemaFinder,
GenericSearchOptionResolver<ArangoQuery> genericFilterOptionResolver
) {
super(structureSchemaFinder, genericFilterOptionResolver);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof AllMatchFilterOption;
}
@Override
protected ArangoQuery postProcessResolvedFilter(
ArangoQuery resolvedFilter,
ArangoSearchResolvingContext context
) {
var resolvedFilterWithParentheses = super.postProcessResolvedFilter(resolvedFilter, context);
var parentheses = (AqlParentheses) resolvedFilterWithParentheses.getAqlNode();
if (parentheses.getAqlNode() instanceof AqlOperatorStatement operatorStatement) {
var operator = operatorStatement.getOperator();
var rightExpression = operatorStatement.getRightExpression();
var operatorAndRightHand = this.getOperatorAndRightHand(
operator,
rightExpression,
CollectionComparisonOperator.ALL
);
return new ArangoQuery(
new AqlParentheses(
new AqlRootNode(
operatorStatement.getLeftExpression(),
operatorAndRightHand
)
),
resolvedFilterWithParentheses.getBindParameters()
);
} else {
var rootNode = (AqlRootNode) parentheses.getAqlNode();
var questionMarkOperator = rootNode.getAqlNodeList().stream()
.filter(AqlQuestionMarkOperator.class::isInstance)
.map(AqlQuestionMarkOperator.class::cast)
.findFirst()
.orElseThrow();
var oldRightHand = (AqlRootNode) questionMarkOperator.getDeepestRightHandExpression();
var operatorAndRightHand = this.getOperatorAndRightHand(
(AqlOperator) Objects.requireNonNull(oldRightHand).getAqlNodeList().get(0),
oldRightHand.getAqlNodeList().get(1),
CollectionComparisonOperator.ALL
);
questionMarkOperator.setRightHandExpression(operatorAndRightHand);
return resolvedFilterWithParentheses;
}
}
@Override
protected SearchResolvingContext createLeafChildContext(
ArangoSearchResolvingContext parentContext, Integer leafIndex) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"allMatch_" + parentContext.getPlaceholderPostfix() + leafIndex,
parentContext.getSubQueryPostfix()
);
}
@Override
protected SearchResolvingContext createCompositeChildContext(
ArangoSearchResolvingContext parentContext
) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"allMatch_" + parentContext.getPlaceholderPostfix(),
parentContext.getSubQueryPostfix()
);
}
@Override
protected ArangoQuery reduceChildResolvedFilters(
ArangoQuery reduced,
ArangoQuery childResolvedFilter
) {
var mergedBindParam = new HashMap<String, Object>();
mergedBindParam.putAll(reduced.getBindParameters());
mergedBindParam.putAll(childResolvedFilter.getBindParameters());
return reduced;
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoAndFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.logicalOperators.AqlAnd;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.GenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.SearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AndFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
public class ArangoAndFilterOptionResolver extends AbstractArangoCompositeFilterOptionResolver<AndFilterOption> {
public ArangoAndFilterOptionResolver(
StructureSchemaFinder structureSchemaFinder,
GenericSearchOptionResolver<ArangoQuery> genericSearchOptionResolver
) {
super(structureSchemaFinder, genericSearchOptionResolver);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof AndFilterOption;
}
@Override
protected SearchResolvingContext createLeafChildContext(
ArangoSearchResolvingContext parentContext, Integer leafIndex) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"and_" + parentContext.getPlaceholderPostfix() + leafIndex,
parentContext.getSubQueryPostfix()
);
}
@Override
protected SearchResolvingContext createCompositeChildContext(
ArangoSearchResolvingContext parentContext) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"and_" + parentContext.getPlaceholderPostfix(),
parentContext.getSubQueryPostfix()
);
}
@Override
protected ArangoQuery reduceChildResolvedFilters(
ArangoQuery reduced,
ArangoQuery childResolvedFilter
) {
var mergedBindParam = new HashMap<String, Object>();
mergedBindParam.putAll(reduced.getBindParameters());
mergedBindParam.putAll(childResolvedFilter.getBindParameters());
return new ArangoQuery(
new AqlAnd(reduced.getAqlNode(), childResolvedFilter.getAqlNode()),
mergedBindParam
);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoAnyMatchFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperatorStatement;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlRootNode;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlParentheses;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlQuestionMarkOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.CollectionComparisonOperator;
import ai.stapi.graphoperations.graphLoader.search.GenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.SearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AnyMatchFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
import java.util.Objects;
public class ArangoAnyMatchFilterOptionResolver
extends AbstractArangoCompositeFilterOptionResolver<AnyMatchFilterOption> {
public ArangoAnyMatchFilterOptionResolver(
StructureSchemaFinder structureSchemaFinder,
GenericSearchOptionResolver<ArangoQuery> genericFilterOptionResolver
) {
super(structureSchemaFinder, genericFilterOptionResolver);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof AnyMatchFilterOption;
}
@Override
protected ArangoQuery postProcessResolvedFilter(ArangoQuery resolvedFilter,
ArangoSearchResolvingContext context) {
var resolvedFilterWithParentheses = super.postProcessResolvedFilter(resolvedFilter, context);
var parentheses = (AqlParentheses) resolvedFilterWithParentheses.getAqlNode();
if (parentheses.getAqlNode() instanceof AqlOperatorStatement operatorStatement) {
var operator = operatorStatement.getOperator();
var rightExpression = operatorStatement.getRightExpression();
var operatorAndRightHand = this.getOperatorAndRightHand(
operator,
rightExpression,
CollectionComparisonOperator.ANY
);
return new ArangoQuery(
new AqlParentheses(
new AqlRootNode(
operatorStatement.getLeftExpression(),
operatorAndRightHand
)
),
resolvedFilterWithParentheses.getBindParameters()
);
} else {
var rootNode = (AqlRootNode) parentheses.getAqlNode();
var questionMarkOperator = rootNode.getAqlNodeList().stream()
.filter(AqlQuestionMarkOperator.class::isInstance)
.map(AqlQuestionMarkOperator.class::cast)
.findFirst()
.orElseThrow();
var oldRightHand = (AqlRootNode) questionMarkOperator.getDeepestRightHandExpression();
var operatorAndRightHand = this.getOperatorAndRightHand(
(AqlOperator) Objects.requireNonNull(oldRightHand).getAqlNodeList().get(0),
oldRightHand.getAqlNodeList().get(1),
CollectionComparisonOperator.ANY
);
questionMarkOperator.setRightHandExpression(operatorAndRightHand);
return resolvedFilterWithParentheses;
}
}
@Override
protected SearchResolvingContext createLeafChildContext(
ArangoSearchResolvingContext parentContext, Integer leafIndex) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"anyMatch_" + parentContext.getPlaceholderPostfix() + leafIndex,
parentContext.getSubQueryPostfix()
);
}
@Override
protected SearchResolvingContext createCompositeChildContext(
ArangoSearchResolvingContext parentContext) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"anyMatch_" + parentContext.getPlaceholderPostfix(),
parentContext.getSubQueryPostfix()
);
}
@Override
protected ArangoQuery reduceChildResolvedFilters(
ArangoQuery reduced,
ArangoQuery childResolvedFilter
) {
var mergedBindParam = new HashMap<String, Object>();
mergedBindParam.putAll(reduced.getBindParameters());
mergedBindParam.putAll(childResolvedFilter.getBindParameters());
return reduced;
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoAscendingSortOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlSortOption;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.GraphLoaderReturnType;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.AscendingSortOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
public class ArangoAscendingSortOptionResolver
extends AbstractArangoSearchOptionResolver<AscendingSortOption> {
public ArangoAscendingSortOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOGMFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof AscendingSortOption;
}
@Override
protected ArangoQuery resolveTyped(AscendingSortOption option,
ArangoSearchResolvingContext context) {
var attributeTypePlaceholder =
this.createAttributeNamePlaceholder(context, option.getOptionType());
var searchOptionSubQueryPostfix =
this.createSearchOptionSubQueryPostfix(context, option.getOptionType());
var bindParameters = new HashMap<String, Object>();
if (option.isLeaf()) {
bindParameters.put(attributeTypePlaceholder, option.getAttributeName());
var sort = AqlSortOption.asc(
this.getFirstAttributeValue(context, attributeTypePlaceholder)
);
return new ArangoQuery(sort, bindParameters);
}
var searchOptionSubQuery = this.createSearchOptionSubQuery(
option.getParameters(),
context,
searchOptionSubQueryPostfix,
GraphLoaderReturnType.SORT_OPTION
);
return new ArangoQuery(
AqlSortOption.asc(searchOptionSubQuery.getAqlNode()),
searchOptionSubQuery.getBindParameters()
);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoContainsFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.ContainsFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoContainsFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<ContainsFilterOption> {
public ArangoContainsFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOGMFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof ContainsFilterOption;
}
@Override
public ArangoQuery resolveTyped(
ContainsFilterOption option,
ArangoSearchResolvingContext context
) {
var decoratedValue = "%" + option.getParameters().getAttributeValue() + "%";
var aqlOperator = AqlOperator.like();
return this.getArangoQuery(option, context, decoratedValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoDescendingSortOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlSortOption;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.GraphLoaderReturnType;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.sortOption.DescendingSortOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
public class ArangoDescendingSortOptionResolver
extends AbstractArangoSearchOptionResolver<DescendingSortOption> {
public ArangoDescendingSortOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(arangoGenericSearchOptionResolver, structureSchemaFinder, genericSubQueryResolver,
graphLoaderOGMFactory);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof DescendingSortOption;
}
@Override
protected ArangoQuery resolveTyped(DescendingSortOption option,
ArangoSearchResolvingContext context) {
var attributeTypePlaceholder =
this.createAttributeNamePlaceholder(context, option.getOptionType());
var searchOptionSubQueryPostfix =
this.createSearchOptionSubQueryPostfix(context, option.getOptionType());
var bindParameters = new HashMap<String, Object>();
if (option.isLeaf()) {
bindParameters.put(attributeTypePlaceholder, option.getAttributeName());
var sort = AqlSortOption.desc(
this.getFirstAttributeValue(context, attributeTypePlaceholder)
);
return new ArangoQuery(sort, bindParameters);
}
var searchOptionSubQuery = this.createSearchOptionSubQuery(
option.getParameters(),
context,
searchOptionSubQueryPostfix,
GraphLoaderReturnType.SORT_OPTION
);
return new ArangoQuery(
AqlSortOption.desc(searchOptionSubQuery.getAqlNode()),
searchOptionSubQuery.getBindParameters()
);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoEndsWithFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EndsWithFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoEndsWithFilterOptionResolver extends AbstractArangoOneValueFilterOprionResolver<EndsWithFilterOption> {
public ArangoEndsWithFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOGMFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof EndsWithFilterOption;
}
@Override
public ArangoQuery resolveTyped(
EndsWithFilterOption option,
ArangoSearchResolvingContext context
) {
var decoratedValue = "%" + option.getParameters().getAttributeValue();
var aqlOperator = AqlOperator.like();
return this.getArangoQuery(option, context, decoratedValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoEqualsFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EqualsFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoEqualsFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<EqualsFilterOption<?>> {
public ArangoEqualsFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder, GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOgmFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOgmFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof EqualsFilterOption<?>;
}
@Override
protected ArangoQuery resolveTyped(
EqualsFilterOption<?> option,
ArangoSearchResolvingContext context
) {
var decoratedValue = option.getParameters().getAttributeValue();
var aqlOperator = AqlOperator.equality();
return this.getArangoQuery(option, context, decoratedValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoGenericSearchOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.graphoperations.graphLoader.search.AbstractGenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOptionResolver;
import java.util.List;
public class ArangoGenericSearchOptionResolver extends AbstractGenericSearchOptionResolver<ArangoQuery> {
public ArangoGenericSearchOptionResolver(List<SearchOptionResolver<ArangoQuery>> searchOptionResolvers) {
super(searchOptionResolvers);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoGreaterThanFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoGreaterThanFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<GreaterThanFilterOption<?>> {
public ArangoGreaterThanFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOGMFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof GreaterThanFilterOption<?>;
}
@Override
public ArangoQuery resolveTyped(
GreaterThanFilterOption<?> option,
ArangoSearchResolvingContext context
) {
var greaterThan = AqlOperator.greaterThan();
var decoratedValue = option.getParameters().getAttributeValue();
return this.getArangoQuery(option, context, decoratedValue, greaterThan);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoGreaterThanOrEqualFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.GreaterThanOrEqualFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoGreaterThanOrEqualFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<GreaterThanOrEqualFilterOption<?>> {
public ArangoGreaterThanOrEqualFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOgmFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOgmFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof GreaterThanOrEqualFilterOption<?>;
}
@Override
public ArangoQuery resolveTyped(
GreaterThanOrEqualFilterOption<?> option,
ArangoSearchResolvingContext context
) {
var aqlOperator = AqlOperator.greaterOrEqual();
var decoratedValue = option.getParameters().getAttributeValue();
return this.getArangoQuery(option, context, decoratedValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoLowerThanFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoLowerThanFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<LowerThanFilterOption<?>> {
public ArangoLowerThanFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOgmFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOgmFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof LowerThanFilterOption<?>;
}
@Override
public ArangoQuery resolveTyped(
LowerThanFilterOption<?> option,
ArangoSearchResolvingContext context
) {
var aqlOperator = AqlOperator.lessThan();
var decoratedValue = option.getParameters().getAttributeValue();
return this.getArangoQuery(option, context, decoratedValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoLowerThanOrEqualFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.LowerThanOrEqualsFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoLowerThanOrEqualFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<LowerThanOrEqualsFilterOption<?>> {
public ArangoLowerThanOrEqualFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOgmFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOgmFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof LowerThanOrEqualsFilterOption<?>;
}
@Override
public ArangoQuery resolveTyped(
LowerThanOrEqualsFilterOption<?> option,
ArangoSearchResolvingContext context
) {
var aqlOperator = AqlOperator.lessOrEqual();
var decoratedValue = option.getParameters().getAttributeValue();
return this.getArangoQuery(option, context, decoratedValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoNoneMatchFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperatorStatement;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlRootNode;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlParentheses;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlQuestionMarkOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.CollectionComparisonOperator;
import ai.stapi.graphoperations.graphLoader.search.GenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.SearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NoneMatchFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
import java.util.Objects;
public class ArangoNoneMatchFilterOptionResolver
extends AbstractArangoCompositeFilterOptionResolver<NoneMatchFilterOption> {
public ArangoNoneMatchFilterOptionResolver(
StructureSchemaFinder structureSchemaFinder,
GenericSearchOptionResolver<ArangoQuery> genericFilterOptionResolver
) {
super(structureSchemaFinder, genericFilterOptionResolver);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof NoneMatchFilterOption;
}
@Override
protected ArangoQuery postProcessResolvedFilter(ArangoQuery resolvedFilter,
ArangoSearchResolvingContext context) {
var resolvedFilterWithParentheses = super.postProcessResolvedFilter(resolvedFilter, context);
var parentheses = (AqlParentheses) resolvedFilterWithParentheses.getAqlNode();
if (parentheses.getAqlNode() instanceof AqlOperatorStatement operatorStatement) {
var operator = operatorStatement.getOperator();
var rightExpression = operatorStatement.getRightExpression();
var operatorAndRightHand = this.getOperatorAndRightHand(
operator,
rightExpression,
CollectionComparisonOperator.NONE
);
return new ArangoQuery(
new AqlParentheses(
new AqlRootNode(
operatorStatement.getLeftExpression(),
operatorAndRightHand
)
),
resolvedFilterWithParentheses.getBindParameters()
);
} else {
var rootNode = (AqlRootNode) parentheses.getAqlNode();
var questionMarkOperator = rootNode.getAqlNodeList().stream()
.filter(AqlQuestionMarkOperator.class::isInstance)
.map(AqlQuestionMarkOperator.class::cast)
.findFirst()
.orElseThrow();
var oldRightHand = (AqlRootNode) questionMarkOperator.getDeepestRightHandExpression();
var operatorAndRightHand = this.getOperatorAndRightHand(
(AqlOperator) Objects.requireNonNull(oldRightHand).getAqlNodeList().get(0),
oldRightHand.getAqlNodeList().get(1),
CollectionComparisonOperator.NONE
);
questionMarkOperator.setRightHandExpression(operatorAndRightHand);
return resolvedFilterWithParentheses;
}
}
@Override
protected SearchResolvingContext createLeafChildContext(
ArangoSearchResolvingContext parentContext, Integer leafIndex) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"allMatch_" + parentContext.getPlaceholderPostfix() + leafIndex,
parentContext.getSubQueryPostfix()
);
}
@Override
protected SearchResolvingContext createCompositeChildContext(
ArangoSearchResolvingContext parentContext) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"allMatch_" + parentContext.getPlaceholderPostfix(),
parentContext.getSubQueryPostfix()
);
}
@Override
protected ArangoQuery reduceChildResolvedFilters(
ArangoQuery reduced,
ArangoQuery childResolvedFilter
) {
var mergedBindParam = new HashMap<String, Object>();
mergedBindParam.putAll(reduced.getBindParameters());
mergedBindParam.putAll(childResolvedFilter.getBindParameters());
return reduced;
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoNotEqualsFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotEqualsFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoNotEqualsFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<NotEqualsFilterOption<?>> {
public ArangoNotEqualsFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOgmFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOgmFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof NotEqualsFilterOption<?>;
}
@Override
protected ArangoQuery resolveTyped(
NotEqualsFilterOption<?> option,
ArangoSearchResolvingContext context
) {
var attributeValue = option.getParameters().getAttributeValue();
var aqlOperator = AqlOperator.inequality();
return this.getArangoQuery(option, context, attributeValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoNotFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.logicalOperators.AqlNot;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.GenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.SearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.NotFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
public class ArangoNotFilterOptionResolver
extends AbstractArangoCompositeFilterOptionResolver<NotFilterOption> {
public ArangoNotFilterOptionResolver(
StructureSchemaFinder structureSchemaFinder,
GenericSearchOptionResolver<ArangoQuery> genericFilterOptionResolver
) {
super(structureSchemaFinder, genericFilterOptionResolver);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof NotFilterOption;
}
@Override
protected ArangoQuery postProcessResolvedFilter(ArangoQuery resolvedFilter,
ArangoSearchResolvingContext context) {
var resolvedFilterWithParentheses = super.postProcessResolvedFilter(resolvedFilter, context);
return new ArangoQuery(
new AqlNot(resolvedFilterWithParentheses.getAqlNode()),
resolvedFilterWithParentheses.getBindParameters()
);
}
@Override
protected SearchResolvingContext createLeafChildContext(
ArangoSearchResolvingContext parentContext, Integer leafIndex) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"not_" + parentContext.getPlaceholderPostfix() + leafIndex,
parentContext.getSubQueryPostfix()
);
}
@Override
protected SearchResolvingContext createCompositeChildContext(
ArangoSearchResolvingContext parentContext) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"not_" + parentContext.getPlaceholderPostfix(),
parentContext.getSubQueryPostfix()
);
}
@Override
protected ArangoQuery reduceChildResolvedFilters(
ArangoQuery reduced,
ArangoQuery childResolvedFilter
) {
var mergedBindParam = new HashMap<String, Object>();
mergedBindParam.putAll(reduced.getBindParameters());
mergedBindParam.putAll(childResolvedFilter.getBindParameters());
return reduced;
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoOffsetPaginationOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlVariable;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.highLevelOperations.AqlLimit;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.OffsetPaginationOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
public class ArangoOffsetPaginationOptionResolver
extends AbstractArangoSearchOptionResolver<OffsetPaginationOption> {
public ArangoOffsetPaginationOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOgmFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOgmFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof OffsetPaginationOption;
}
@Override
protected ArangoQuery resolveTyped(
OffsetPaginationOption option,
ArangoSearchResolvingContext context
) {
var postfix = context.getSubQueryPostfix();
var offset = postfix.isBlank() ? "offset" : String.format("offset__%s", postfix);
var limit = postfix.isBlank() ? "limit" : String.format("limit__%s", postfix);
var bindParameters = new HashMap<String, Object>();
bindParameters.put(offset, option.getParameters().getOffset());
bindParameters.put(limit, option.getParameters().getLimit());
return new ArangoQuery(
new AqlLimit(
new AqlVariable(limit).markAsBindParameter(),
new AqlVariable(offset).markAsBindParameter()
),
bindParameters
);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoOrFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.logicalOperators.AqlOr;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.GenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.SearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.search.filterOption.OrFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.HashMap;
public class ArangoOrFilterOptionResolver
extends AbstractArangoCompositeFilterOptionResolver<OrFilterOption> {
public ArangoOrFilterOptionResolver(
StructureSchemaFinder structureSchemaFinder,
GenericSearchOptionResolver<ArangoQuery> genericFilterOptionResolver
) {
super(structureSchemaFinder, genericFilterOptionResolver);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof OrFilterOption;
}
@Override
protected SearchResolvingContext createLeafChildContext(
ArangoSearchResolvingContext parentContext, Integer leafIndex) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"or_" + parentContext.getPlaceholderPostfix() + leafIndex,
parentContext.getSubQueryPostfix()
);
}
@Override
protected SearchResolvingContext createCompositeChildContext(
ArangoSearchResolvingContext parentContext) {
return new ArangoSearchResolvingContext(
parentContext.getDocumentName(),
parentContext.getOriginQueryType(),
parentContext.getGraphElementType(),
"or_" + parentContext.getPlaceholderPostfix(),
parentContext.getSubQueryPostfix()
);
}
@Override
protected ArangoQuery reduceChildResolvedFilters(
ArangoQuery reduced,
ArangoQuery childResolvedFilter
) {
var mergedBindParam = new HashMap<String, Object>();
mergedBindParam.putAll(reduced.getBindParameters());
mergedBindParam.putAll(childResolvedFilter.getBindParameters());
return new ArangoQuery(
new AqlOr(reduced.getAqlNode(), childResolvedFilter.getAqlNode()),
mergedBindParam
);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/graphLoader/arangoQuery/searchOptionResolvers/ArangoStartsWithFilterOptionResolver.java | package ai.stapi.arangograph.graphLoader.arangoQuery.searchOptionResolvers;
import ai.stapi.arangograph.graphLoader.arangoQuery.ArangoQuery;
import ai.stapi.arangograph.graphLoader.arangoQuery.arangoSubQueryResolver.GenericSubQueryResolver;
import ai.stapi.arangograph.graphLoader.arangoQuery.ast.AqlOperator;
import ai.stapi.arangograph.graphLoader.arangoQuery.builder.ArangoSearchResolvingContext;
import ai.stapi.graphoperations.graphLoader.graphLoaderOGMFactory.GraphLoaderOgmFactory;
import ai.stapi.graphoperations.graphLoader.search.SearchOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.StartsWithFilterOption;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
public class ArangoStartsWithFilterOptionResolver
extends AbstractArangoOneValueFilterOprionResolver<StartsWithFilterOption> {
public ArangoStartsWithFilterOptionResolver(
ArangoGenericSearchOptionResolver arangoGenericSearchOptionResolver,
StructureSchemaFinder structureSchemaFinder,
GenericSubQueryResolver genericSubQueryResolver,
GraphLoaderOgmFactory graphLoaderOGMFactory
) {
super(
arangoGenericSearchOptionResolver,
structureSchemaFinder,
genericSubQueryResolver,
graphLoaderOGMFactory
);
}
@Override
public boolean supports(SearchOption<?> option) {
return option instanceof StartsWithFilterOption;
}
@Override
public ArangoQuery resolveTyped(
StartsWithFilterOption option,
ArangoSearchResolvingContext context
) {
var decoratedValue = option.getParameters().getAttributeValue() + "%";
var aqlOperator = AqlOperator.like();
return this.getArangoQuery(option, context, decoratedValue, aqlOperator);
}
}
|
0 | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph | java-sources/ai/stapi/arango-graph/0.0.2/ai/stapi/arangograph/repositorypruner/ArangoRepositoryPruner.java | package ai.stapi.arangograph.repositorypruner;
import ai.stapi.graph.repositorypruner.RepositoryPruner;
import com.arangodb.ArangoDB;
import com.arangodb.model.CollectionsReadOptions;
public class ArangoRepositoryPruner implements RepositoryPruner {
private final ArangoDB arangoDB;
public ArangoRepositoryPruner(ArangoDB arangoDB) {
this.arangoDB = arangoDB;
}
@Override
public void prune() {
this.arangoDB.db().getCollections(new CollectionsReadOptions().excludeSystem(true)).forEach(
collectionEntity -> arangoDB.db().collection(collectionEntity.getName()).drop()
);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/commandpersisting/CommandFixturesCommitted.java | package ai.stapi.axonsystem.commandpersisting;
import ai.stapi.graphsystem.messaging.event.Event;
public class CommandFixturesCommitted implements Event {
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/commandpersisting/CommandMessageStore.java | package ai.stapi.axonsystem.commandpersisting;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphsystem.messaging.command.AbstractPayloadCommand;
import java.util.HashMap;
import java.util.List;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.commandhandling.distributed.AnnotationRoutingStrategy;
public interface CommandMessageStore {
void storeCommand(CommandMessage<?> commandMessage);
List<PersistedCommandMessage<?>> getAll();
void wipeAll();
default String extractId(CommandMessage<?> commandMessage) {
var routingStrategy = AnnotationRoutingStrategy.builder().build();
var payload = commandMessage.getPayload();
if (payload instanceof AbstractCommand<?> abstractCommand) {
return abstractCommand.getTargetIdentifier().getId();
} else {
return routingStrategy.getRoutingKey(commandMessage);
}
}
default Object extractPayload(CommandMessage<?> commandMessage) {
var payload = commandMessage.getPayload();
if (payload instanceof AbstractPayloadCommand<?> abstractCreateResourceCommand) {
var finalPayload = new HashMap<>(abstractCreateResourceCommand.getData());
finalPayload.put(
"id",
abstractCreateResourceCommand.getTargetIdentifier().getId()
);
payload = finalPayload;
}
return payload;
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/commandpersisting/CommitCommandFixtures.java | package ai.stapi.axonsystem.commandpersisting;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
public class CommitCommandFixtures extends AbstractCommand<UniqueIdentifier> {
public static final String TARGET_AGGREGATE_IDENTIFIER = "CommitCommandFixtures";
public static final String SERIALIZATION_TYPE = "CommitCommandFixtures";
private String outputDirectoryPath;
protected CommitCommandFixtures() {
}
public CommitCommandFixtures(String outputDirectoryPath) {
super(new UniqueIdentifier(TARGET_AGGREGATE_IDENTIFIER), SERIALIZATION_TYPE);
this.outputDirectoryPath = outputDirectoryPath;
}
public String getOutputDirectoryPath() {
return outputDirectoryPath;
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/commandpersisting/InMemoryCommandMessageStore.java | package ai.stapi.axonsystem.commandpersisting;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.axonframework.commandhandling.CommandMessage;
public class InMemoryCommandMessageStore implements CommandMessageStore {
private final List<PersistedCommandMessage<?>> persistedCommandMessages;
public InMemoryCommandMessageStore() {
this.persistedCommandMessages = new ArrayList<>();
}
@Override
public void storeCommand(CommandMessage<?> commandMessage) {
var id = this.extractId(commandMessage);
var payload = this.extractPayload(commandMessage);
var persisted = new InMemoryPersistedCommandMessage<>(
commandMessage.getIdentifier(),
commandMessage.getCommandName(),
payload,
commandMessage.getMetaData(),
id
);
this.persistedCommandMessages.add(persisted);
}
@Override
public List<PersistedCommandMessage<?>> getAll() {
return this.persistedCommandMessages;
}
@Override
public void wipeAll() {
this.persistedCommandMessages.clear();
}
private static class InMemoryPersistedCommandMessage<T> implements PersistedCommandMessage<T> {
@JsonIgnore
private final String key;
private final String commandName;
private final T commandPayload;
private final Map<String, Object> commandMetaData;
private final String targetAggregateIdentifier;
public InMemoryPersistedCommandMessage(
String key,
String commandName,
T commandPayload,
Map<String, Object> commandMetaData,
String targetAggregateIdentifier
) {
this.key = key;
this.commandName = commandName;
this.commandPayload = commandPayload;
this.commandMetaData = commandMetaData;
this.targetAggregateIdentifier = targetAggregateIdentifier;
}
@Override
@JsonIgnore
public String getKey() {
return this.key;
}
@Override
public String getCommandName() {
return this.commandName;
}
@Override
public T getCommandPayload() {
return this.commandPayload;
}
@Override
public Map<String, Object> getCommandMetaData() {
return this.commandMetaData;
}
@Override
public String getTargetAggregateIdentifier() {
return this.targetAggregateIdentifier;
}
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/commandpersisting/PersistCommandInterceptor.java | package ai.stapi.axonsystem.commandpersisting;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.messaging.InterceptorChain;
import org.axonframework.messaging.MessageHandlerInterceptor;
import org.axonframework.messaging.unitofwork.UnitOfWork;
import org.jetbrains.annotations.NotNull;
public class PersistCommandInterceptor implements MessageHandlerInterceptor<CommandMessage<?>> {
private final CommandMessageStore commandMessageStore;
public PersistCommandInterceptor(CommandMessageStore commandMessageStore) {
this.commandMessageStore = commandMessageStore;
}
@Override
public Object handle(
@NotNull UnitOfWork<? extends CommandMessage<?>> unitOfWork,
@NotNull InterceptorChain interceptorChain
) throws Exception {
unitOfWork.afterCommit(unitOfWorkAfterCommit -> {
var message = unitOfWorkAfterCommit.getMessage();
this.commandMessageStore.storeCommand(message);
});
return interceptorChain.proceed();
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/commandpersisting/PersistedCommandMessage.java | package ai.stapi.axonsystem.commandpersisting;
import java.util.Map;
public interface PersistedCommandMessage<T> {
String getKey();
String getCommandName();
T getCommandPayload();
Map<String, Object> getCommandMetaData();
String getTargetAggregateIdentifier();
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/commandvalidation/CommandValidatorDispatchInterceptor.java | package ai.stapi.axonsystem.commandvalidation;
import ai.stapi.graphsystem.commandvalidation.model.exceptions.CannotDispatchCommand;
import ai.stapi.graphsystem.commandvalidation.model.CommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.CommandValidator;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.messaging.command.Command;
import java.util.List;
import java.util.function.BiFunction;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.messaging.MessageDispatchInterceptor;
import org.jetbrains.annotations.NotNull;
public class CommandValidatorDispatchInterceptor implements MessageDispatchInterceptor<CommandMessage<?>> {
private final CommandValidator commandValidator;
public CommandValidatorDispatchInterceptor(CommandValidator commandValidator) {
this.commandValidator = commandValidator;
}
@NotNull
@Override
public BiFunction<Integer, CommandMessage<?>, CommandMessage<?>> handle(
@NotNull List<? extends CommandMessage<?>> messages
) {
return (index, commandMessage) -> {
var payload = commandMessage.getPayload();
if (!(payload instanceof Command)) {
throw CannotDispatchCommand.becauseItDoesNotImplementCommandInterface(
commandMessage.getCommandName(),
payload.getClass()
);
}
if (payload instanceof DynamicCommand command) {
var violations = this.commandValidator.validate(command);
if (this.isThereErrorViolation(violations)) {
throw CannotDispatchCommand.becauseThereWereConstrainViolation(
command.getSerializationType(),
command.getTargetIdentifier().getId(),
violations
);
}
}
return commandMessage;
};
}
private boolean isThereErrorViolation(List<CommandConstrainViolation> violations) {
return violations.stream().anyMatch(
violation -> violation.getLevel().equals(CommandConstrainViolation.Level.ERROR)
);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration/CommandGatewayConfiguration.java | package ai.stapi.axonsystem.configuration;
import ai.stapi.axonsystem.commandvalidation.CommandValidatorDispatchInterceptor;
import ai.stapi.axonsystem.configuration.implementations.CommandDispatchedAtInterceptor;
import ai.stapi.axonsystem.configuration.implementations.CustomFailureLoggingCallback;
import ai.stapi.graphsystem.commandvalidation.model.CommandValidator;
import java.util.List;
import java.util.logging.Logger;
import org.axonframework.commandhandling.CommandBus;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.commandhandling.DuplicateCommandHandlerResolver;
import org.axonframework.commandhandling.SimpleCommandBus;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.commandhandling.gateway.DefaultCommandGateway;
import org.axonframework.common.transaction.TransactionManager;
import org.axonframework.messaging.MessageDispatchInterceptor;
import org.axonframework.messaging.MessageHandlerInterceptor;
import org.axonframework.messaging.correlation.CorrelationDataProvider;
import org.axonframework.messaging.correlation.MessageOriginProvider;
import org.axonframework.messaging.interceptors.CorrelationDataInterceptor;
import org.axonframework.springboot.autoconfig.EventProcessingAutoConfiguration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
@AutoConfiguration
@AutoConfigureAfter({EventProcessingAutoConfiguration.class})
public class CommandGatewayConfiguration {
@Bean
@ConditionalOnMissingBean
public CommandGateway configuredCommandGateway(
@Autowired CommandBus commandBus,
@Autowired List<MessageDispatchInterceptor<? super CommandMessage<?>>> messageDispatchInterceptors
) {
var failureCommandCallback = new CustomFailureLoggingCallback<>(
Logger.getLogger(DefaultCommandGateway.class.getSimpleName())
);
return DefaultCommandGateway.builder()
.commandBus(commandBus)
.commandCallback(failureCommandCallback)
.dispatchInterceptors(messageDispatchInterceptors)
.build();
}
@Bean
@ConditionalOnMissingBean(
ignoredType = {
"org.axonframework.commandhandling.distributed.DistributedCommandBus",
"org.axonframework.axonserver.connector.command.AxonServerCommandBus",
"org.axonframework.extensions.multitenancy.components.commandhandeling.MultiTenantCommandBus"
},
value = {CommandBus.class}
)
@Qualifier("localSegment")
public SimpleCommandBus configuredCommandBus(
@Autowired TransactionManager txManager,
@Autowired org.axonframework.config.Configuration axonConfiguration,
@Autowired DuplicateCommandHandlerResolver duplicateCommandHandlerResolver,
@Autowired List<MessageHandlerInterceptor<? super CommandMessage<?>>> messageHandlerInterceptors
) {
var commandBus = SimpleCommandBus.builder()
.transactionManager(txManager)
.duplicateCommandHandlerResolver(duplicateCommandHandlerResolver)
.spanFactory(axonConfiguration.spanFactory())
.messageMonitor(axonConfiguration.messageMonitor(CommandBus.class, "commandBus"))
.build();
commandBus.registerHandlerInterceptor(
new CorrelationDataInterceptor<>(axonConfiguration.correlationDataProviders())
);
messageHandlerInterceptors.forEach(commandBus::registerHandlerInterceptor);
return commandBus;
}
@Bean
public CommandDispatchedAtInterceptor commandDispatchedAtInterceptor() {
return new CommandDispatchedAtInterceptor();
}
@Bean
@Profile("dev")
public CommandValidatorDispatchInterceptor commandValidatorDispatchInterceptor(
CommandValidator commandValidator
) {
return new CommandValidatorDispatchInterceptor(commandValidator);
}
@Bean
public CorrelationDataProvider messageCorrelationProvider() {
return new MessageOriginProvider();
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration/CommandPersistingConfiguration.java | package ai.stapi.axonsystem.configuration;
import ai.stapi.axonsystem.commandpersisting.CommandMessageStore;
import ai.stapi.axonsystem.commandpersisting.InMemoryCommandMessageStore;
import ai.stapi.axonsystem.commandpersisting.PersistCommandInterceptor;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
@AutoConfiguration
public class CommandPersistingConfiguration {
@Bean
@ConditionalOnMissingBean(CommandMessageStore.class)
public InMemoryCommandMessageStore inMemoryCommandMessageStore() {
return new InMemoryCommandMessageStore();
}
@Bean
@ConditionalOnBean(CommandMessageStore.class)
@Profile("dev")
public PersistCommandInterceptor persistCommandInterceptor(
CommandMessageStore commandMessageStore
) {
return new PersistCommandInterceptor(commandMessageStore);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration/DynamicAxonConfiguration.java | package ai.stapi.axonsystem.configuration;
import ai.stapi.axonsystem.dynamic.aggregate.AggregateDefinitionDACProvider;
import ai.stapi.axonsystem.dynamic.aggregate.DynamicAggregateConfigurationsProvider;
import ai.stapi.axonsystem.dynamic.aggregate.DynamicAggregateConfigurer;
import ai.stapi.axonsystem.dynamic.aggregate.RuntimeDynamicAggregateConfigurer;
import ai.stapi.axonsystem.dynamic.command.CustomCommandTargetResolver;
import ai.stapi.axonsystem.dynamic.command.DynamicCommandDispatchInterceptor;
import ai.stapi.axonsystem.dynamic.messagehandler.DynamicMessageHandlerLookup;
import ai.stapi.axonsystem.dynamic.messagehandler.DynamicMessageHandlingMemberDefinition;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import org.axonframework.config.Configuration;
import org.axonframework.config.Configurer;
import org.axonframework.eventsourcing.eventstore.EventStore;
import org.axonframework.messaging.annotation.ParameterResolverFactory;
import org.axonframework.modelling.command.CommandTargetResolver;
import org.axonframework.tracing.SpanFactory;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Role;
@AutoConfiguration
public class DynamicAxonConfiguration {
@Bean
public DynamicAggregateConfigurer dynamicAggregateConfigurer(
DynamicAggregateConfigurationsProvider dynamicAggregateConfigurationsProvider,
RuntimeDynamicAggregateConfigurer runtimeDynamicAggregateConfigurer
) {
return new DynamicAggregateConfigurer(
dynamicAggregateConfigurationsProvider,
runtimeDynamicAggregateConfigurer
);
}
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public DynamicMessageHandlerLookup dynamicMessageHandlerLookup() {
return new DynamicMessageHandlerLookup();
}
@Bean
public DynamicMessageHandlingMemberDefinition dynamicMessageHandlingMemberDefinition() {
return new DynamicMessageHandlingMemberDefinition();
}
@Bean
public DynamicCommandDispatchInterceptor dynamicCommandDispatchInterceptor() {
return new DynamicCommandDispatchInterceptor();
}
@Bean
public CustomCommandTargetResolver customCommandTargetResolver() {
return new CustomCommandTargetResolver();
}
@Bean
@ConditionalOnMissingBean(DynamicAggregateConfigurationsProvider.class)
public AggregateDefinitionDACProvider aggregateDefinitionDACProvider(
AggregateDefinitionProvider aggregateDefinitionProvider,
DynamicCommandProcessor dynamicCommandProcessor,
@Lazy EventStore eventStore,
SpanFactory spanFactory,
@Lazy Configuration configuration,
ParameterResolverFactory parameterResolverFactory,
CommandTargetResolver commandTargetResolver
) {
return new AggregateDefinitionDACProvider(
aggregateDefinitionProvider,
dynamicCommandProcessor,
eventStore,
spanFactory,
configuration,
parameterResolverFactory,
commandTargetResolver
);
}
@Bean
public RuntimeDynamicAggregateConfigurer runtimeDynamicAggregateConfigurer(
DynamicAggregateConfigurationsProvider dynamicAggregateConfigurationsProvider,
@Lazy Configurer configurer
) {
return new RuntimeDynamicAggregateConfigurer(
dynamicAggregateConfigurationsProvider,
configurer
);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration/SerializerConfiguration.java | package ai.stapi.axonsystem.configuration;
import ai.stapi.configuration.SerializationConfiguration;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.axonframework.serialization.Serializer;
import org.axonframework.serialization.json.JacksonSerializer;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
@AutoConfigureAfter(SerializationConfiguration.class)
public class SerializerConfiguration {
@Bean
@Qualifier("messageSerializer")
@ConditionalOnBean(ObjectMapper.class)
public Serializer customMessageSerializer(ObjectMapper objectMapper) {
return JacksonSerializer
.builder()
.objectMapper(objectMapper)
.build();
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration/implementations/CommandDispatchedAtInterceptor.java | package ai.stapi.axonsystem.configuration.implementations;
import java.sql.Timestamp;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.messaging.MessageDispatchInterceptor;
import org.springframework.stereotype.Service;
import org.jetbrains.annotations.NotNull;
public class CommandDispatchedAtInterceptor implements MessageDispatchInterceptor<CommandMessage<?>> {
public static final String DISPATCHED_AT_METADATA_KEY = "dispatchedAt";
@NotNull
@Override
public BiFunction<Integer, CommandMessage<?>, CommandMessage<?>> handle(
@NotNull List<? extends CommandMessage<?>> messages
) {
return (index, command) -> {
var stringDate = new Timestamp(System.currentTimeMillis()).toString();
return command.andMetaData(
Map.of(
DISPATCHED_AT_METADATA_KEY, stringDate
)
);
};
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/configuration/implementations/CustomFailureLoggingCallback.java | package ai.stapi.axonsystem.configuration.implementations;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nonnull;
import org.axonframework.commandhandling.CommandCallback;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.commandhandling.CommandResultMessage;
public class CustomFailureLoggingCallback<C, R> implements CommandCallback<C, R> {
private final CommandCallback<C, R> delegate;
private final Logger logger;
public CustomFailureLoggingCallback(Logger logger) {
this.logger = logger;
this.delegate = null;
}
@Override
public void onResult(
@Nonnull CommandMessage<? extends C> commandMessage,
@Nonnull CommandResultMessage<? extends R> commandResultMessage
) {
commandResultMessage.optionalExceptionResult().ifPresent(cause ->
logger.log(
Level.WARNING,
String.format(
"Command '%s' resulted in %s",
commandMessage.getCommandName(),
cause.getClass().getSimpleName()
),
cause
)
);
if (delegate != null) {
delegate.onResult(commandMessage, commandResultMessage);
}
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/AggregateDefinitionDACProvider.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.axonsystem.dynamic.aggregate.exceptions.CannotProvideDynamicAggregateConfiguration;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.CreationPolicy;
import ai.stapi.graphsystem.aggregatedefinition.model.exceptions.CannotProvideAggregateDefinition;
import ai.stapi.axonsystem.dynamic.aggregate.exceptions.CannotProvideDynamicAggregateConfigurationFromAggregateDefinition;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.event.GraphUpdatedEvent;
import java.util.List;
import org.axonframework.config.Configuration;
import org.axonframework.eventhandling.EventMessage;
import org.axonframework.eventsourcing.NoSnapshotTriggerDefinition;
import org.axonframework.eventsourcing.eventstore.EventStore;
import org.axonframework.eventsourcing.snapshotting.RevisionSnapshotFilter;
import org.axonframework.messaging.annotation.AnnotatedMessageHandlingMember;
import org.axonframework.messaging.annotation.ParameterResolverFactory;
import org.axonframework.modelling.command.CommandTargetResolver;
import org.axonframework.tracing.SpanFactory;
import org.jetbrains.annotations.NotNull;
public class AggregateDefinitionDACProvider implements DynamicAggregateConfigurationsProvider {
private final AggregateDefinitionProvider aggregateDefinitionProvider;
private final DynamicCommandProcessor dynamicCommandProcessor;
private final EventStore eventStore;
private final SpanFactory spanFactory;
private final Configuration configuration;
private final ParameterResolverFactory parameterResolverFactory;
private final CommandTargetResolver commandTargetResolver;
public AggregateDefinitionDACProvider(
AggregateDefinitionProvider aggregateDefinitionProvider,
DynamicCommandProcessor dynamicCommandProcessor,
EventStore eventStore,
SpanFactory spanFactory,
Configuration configuration,
ParameterResolverFactory parameterResolverFactory,
CommandTargetResolver commandTargetResolver
) {
this.aggregateDefinitionProvider = aggregateDefinitionProvider;
this.dynamicCommandProcessor = dynamicCommandProcessor;
this.eventStore = eventStore;
this.spanFactory = spanFactory;
this.configuration = configuration;
this.parameterResolverFactory = parameterResolverFactory;
this.commandTargetResolver = commandTargetResolver;
}
@Override
public List<DynamicAggregateConfiguration> provide() {
var aggregateDefinitions = this.aggregateDefinitionProvider.provideAll();
return aggregateDefinitions.stream().map(this::createDynamicAggregateConfiguration).toList();
}
@Override
public DynamicAggregateConfiguration provide(
String aggregateType
) throws CannotProvideDynamicAggregateConfiguration {
AggregateDefinitionDTO aggregateDefinition;
try {
aggregateDefinition = this.aggregateDefinitionProvider.provide(aggregateType);
} catch (CannotProvideAggregateDefinition e) {
throw new CannotProvideDynamicAggregateConfiguration(aggregateType, e);
}
return this.createDynamicAggregateConfiguration(aggregateDefinition);
}
@NotNull
private DynamicAggregateConfiguration createDynamicAggregateConfiguration(
AggregateDefinitionDTO definition
) {
var aggregateType = definition.getName();
var modelBuilder = new DynamicAggregateModel.Builder(aggregateType);
modelBuilder.addEventHandler(this.createOnEventSourcingHandler());
definition.getCommand().stream().map(commandDefinition -> {
var creationalPolicy = commandDefinition.getCreationalPolicy();
var commandName = commandDefinition.getOperation().getId();
if (creationalPolicy.equals(CreationPolicy.ALWAYS)) {
return new DynamicConstructorCommandMessageHandlerMember(
this.dynamicCommandProcessor,
aggregateType,
commandName
);
}
if (creationalPolicy.equals(CreationPolicy.NEVER)) {
return new DynamicMethodCommandMessageHandlerMember(
this.dynamicCommandProcessor,
aggregateType,
commandName
);
}
if (creationalPolicy.equals(CreationPolicy.IF_MISSING)) {
return new DynamicCreateIfMissingCommandMessageHandlerMember(
this.dynamicCommandProcessor,
aggregateType,
commandName
);
}
throw CannotProvideDynamicAggregateConfigurationFromAggregateDefinition.becauseCommandHandlerDefinitionHasUnknownCreationalPolicy(
commandDefinition
);
}).forEach(modelBuilder::addCommandHandler);
return new DynamicAggregateConfiguration(
this.dynamicCommandProcessor,
this.eventStore,
NoSnapshotTriggerDefinition.INSTANCE,
RevisionSnapshotFilter.builder()
.type(aggregateType)
.revision(null)
.build(),
this.configuration::repository,
this.spanFactory,
null,
this.parameterResolverFactory,
this.commandTargetResolver,
modelBuilder.build()
);
}
@NotNull
private AnnotatedMessageHandlingMember<DynamicAggregate> createOnEventSourcingHandler() {
try {
return new AnnotatedMessageHandlingMember<>(
DynamicAggregate.class.getMethod("onEvent", AggregateGraphUpdatedEvent.class),
EventMessage.class,
GraphUpdatedEvent.class,
this.parameterResolverFactory
);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicAggregate.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.axonsystem.graphaggregate.AggregateWithDynamicGraph;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.identity.UniqueIdentifier;
public class DynamicAggregate extends AggregateWithDynamicGraph<UniqueIdentifier> {
private String aggregateType;
protected DynamicAggregate() {
}
public DynamicAggregate(
DynamicCommandProcessor commandProcessor,
String aggregateType
) {
super(commandProcessor);
this.aggregateType = aggregateType;
}
public DynamicAggregate(
DynamicCommandProcessor commandProcessor,
String aggregateType,
DynamicCommand command
) {
super(commandProcessor);
this.aggregateType = aggregateType;
this.processCommandDynamically(command);
}
public void handle(DynamicCommand command) {
this.processCommandDynamically(command);
}
public void onEvent(AggregateGraphUpdatedEvent<UniqueIdentifier> event) {
this.onAggregateCreated(event);
}
public String getAggregateType() {
return aggregateType;
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicAggregateCommandHandler.java | /*
* Copyright (c) 2010-2022. Axon Framework
*
* Licensed 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 ai.stapi.axonsystem.dynamic.aggregate;
import static org.axonframework.common.BuilderUtils.assertNonNull;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.axonframework.commandhandling.CommandBus;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.commandhandling.CommandMessageHandler;
import org.axonframework.commandhandling.NoHandlerForCommandException;
import org.axonframework.common.AxonConfigurationException;
import org.axonframework.common.Registration;
import org.axonframework.messaging.MessageHandler;
import org.axonframework.messaging.annotation.HandlerDefinition;
import org.axonframework.messaging.annotation.MessageHandlingMember;
import org.axonframework.messaging.annotation.ParameterResolverFactory;
import org.axonframework.modelling.command.Aggregate;
import org.axonframework.modelling.command.AggregateNotFoundException;
import org.axonframework.modelling.command.CommandTargetResolver;
import org.axonframework.modelling.command.Repository;
import org.axonframework.modelling.command.VersionedAggregateIdentifier;
import org.axonframework.modelling.command.inspection.AggregateModel;
public class DynamicAggregateCommandHandler implements CommandMessageHandler {
private final Repository<DynamicAggregate> repository;
private final CommandTargetResolver commandTargetResolver;
private final List<MessageHandler<CommandMessage<?>>> handlers;
private final Set<String> supportedCommandNames;
private final Map<String, Set<MessageHandler<CommandMessage<?>>>> supportedCommandsByName;
private final DynamicCommandProcessor dynamicCommandProcessor;
private final DynamicAggregateModel dynamicAggregateModel;
public static Builder builder() {
return new Builder();
}
protected DynamicAggregateCommandHandler(
Builder builder
) {
builder.validate();
this.repository = builder.repository;
this.commandTargetResolver = builder.commandTargetResolver;
this.supportedCommandNames = new HashSet<>();
this.supportedCommandsByName = new HashMap<>();
this.dynamicCommandProcessor = builder.dynamicCommandProcessor;
this.dynamicAggregateModel = builder.buildAggregateModel();
this.handlers = initializeHandlers(this.dynamicAggregateModel);
}
public Registration subscribe(CommandBus commandBus) {
var subscriptions = supportedCommandsByName
.entrySet()
.stream()
.flatMap(entry -> entry.getValue().stream().map(
messageHandler -> commandBus.subscribe(
entry.getKey(),
messageHandler
)
))
.filter(Objects::nonNull)
.toList();
return () -> subscriptions.stream().map(Registration::cancel)
.reduce(Boolean::logicalOr)
.orElse(false);
}
private List<MessageHandler<CommandMessage<?>>> initializeHandlers(
DynamicAggregateModel aggregateModel
) {
List<MessageHandler<CommandMessage<?>>> handlersFound = new ArrayList<>();
aggregateModel.allCommandHandlers()
.values()
.stream()
.flatMap(List::stream)
.forEach(commandHandler -> initializeHandler(
aggregateModel,
commandHandler,
handlersFound
));
return handlersFound;
}
private void initializeHandler(
DynamicAggregateModel dynamicAggregateModel,
MessageHandlingMember<? super DynamicAggregate> handler,
List<MessageHandler<CommandMessage<?>>> handlersFound
) {
MessageHandler<CommandMessage<?>> messageHandler = null;
String commandName = null;
var createHandler = handler.unwrap(
DynamicConstructorCommandMessageHandlerMember.class
);
if (createHandler.isPresent()) {
messageHandler = new AggregateConstructorCommandHandler(createHandler.get());
commandName = createHandler.get().commandName();
}
var createOrUpdate = handler.unwrap(
DynamicCreateIfMissingCommandMessageHandlerMember.class
);
if (createOrUpdate.isPresent()) {
messageHandler = new AggregateCreateOrUpdateCommandHandler(
createOrUpdate.get(),
this.dynamicCommandProcessor,
dynamicAggregateModel.type()
);
commandName = createOrUpdate.get().commandName();
}
var neverHandler = handler.unwrap(
DynamicMethodCommandMessageHandlerMember.class
);
if (neverHandler.isPresent()) {
messageHandler = new AggregateCommandHandler(neverHandler.get());
commandName = neverHandler.get().commandName();
}
if (messageHandler == null) {
throw new UnknownDynamicCommandHandlerException(
"Unknown dynamic command message handling member in aggregate configuration."
);
}
handlersFound.add(messageHandler);
supportedCommandsByName
.computeIfAbsent(commandName, key -> new HashSet<>())
.add(messageHandler);
supportedCommandNames.add(commandName);
}
@Override
public Object handle(CommandMessage<?> commandMessage) throws Exception {
return handlers.stream()
.filter(ch -> ch.canHandle(commandMessage))
.findFirst()
.orElseThrow(() -> new NoHandlerForCommandException(commandMessage))
.handle(commandMessage);
}
@Override
public boolean canHandle(CommandMessage<?> message) {
return handlers.stream().anyMatch(ch -> ch.canHandle(message));
}
protected Object resolveReturnValue(
@SuppressWarnings("unused") CommandMessage<?> command,
Aggregate<DynamicAggregate> createdAggregate
) {
return createdAggregate.identifier();
}
@Override
public Set<String> supportedCommandNames() {
return supportedCommandNames;
}
public static class Builder {
private Repository<DynamicAggregate> repository;
private DynamicCommandProcessor dynamicCommandProcessor;
private CommandTargetResolver commandTargetResolver;
private ParameterResolverFactory parameterResolverFactory;
private HandlerDefinition handlerDefinition;
private DynamicAggregateModel aggregateModel;
public Builder repository(Repository<DynamicAggregate> repository) {
assertNonNull(repository, "Repository may not be null");
this.repository = repository;
return this;
}
public Builder dynamicCommandProcessor(DynamicCommandProcessor dynamicCommandProcessor) {
assertNonNull(dynamicCommandProcessor, "Repository may not be null");
this.dynamicCommandProcessor = dynamicCommandProcessor;
return this;
}
public Builder commandTargetResolver(CommandTargetResolver commandTargetResolver) {
assertNonNull(commandTargetResolver, "CommandTargetResolver may not be null");
this.commandTargetResolver = commandTargetResolver;
return this;
}
public Builder parameterResolverFactory(ParameterResolverFactory parameterResolverFactory) {
assertNonNull(parameterResolverFactory, "ParameterResolverFactory may not be null");
this.parameterResolverFactory = parameterResolverFactory;
return this;
}
public Builder handlerDefinition(HandlerDefinition handlerDefinition) {
assertNonNull(handlerDefinition, "HandlerDefinition may not be null");
this.handlerDefinition = handlerDefinition;
return this;
}
public Builder aggregateModel(DynamicAggregateModel aggregateModel) {
assertNonNull(aggregateModel, "AggregateModel may not be null");
this.aggregateModel = aggregateModel;
return this;
}
/**
* Instantiate the {@link AggregateModel} of generic type {@code T} describing the structure of
* the Aggregate this {@link DynamicAggregateCommandHandler} will handle commands for.
*
* @return a {@link AggregateModel} of generic type {@code T} describing the Aggregate this
* {@link DynamicAggregateCommandHandler} will handle commands for
*/
private DynamicAggregateModel buildAggregateModel() {
return aggregateModel;
}
public DynamicAggregateCommandHandler build() {
return new DynamicAggregateCommandHandler(this);
}
/**
* Validates whether the fields contained in this Builder are set accordingly.
*
* @throws AxonConfigurationException if one field is asserted to be incorrect according to the
* Builder's specifications
*/
protected void validate() throws AxonConfigurationException {
assertNonNull(repository, "The Repository is a hard requirement and should be provided");
assertNonNull(
aggregateModel,
"No AggregateModel is set, but it is a hard requirement"
);
assertNonNull(
dynamicCommandProcessor,
"No Dynamic Command Processor is set, but it is a hard requirement"
);
}
}
private class AggregateConstructorCommandHandler implements MessageHandler<CommandMessage<?>> {
private final MessageHandlingMember<?> handler;
public AggregateConstructorCommandHandler(MessageHandlingMember<?> handler) {
this.handler = handler;
}
@SuppressWarnings("unchecked")
@Override
public Object handle(CommandMessage<?> command) throws Exception {
var aggregate = repository.newInstance(
() -> (DynamicAggregate) handler.handle(command, null)
);
return resolveReturnValue(command, aggregate);
}
@Override
public boolean canHandle(CommandMessage<?> message) {
return handler.canHandle(message);
}
}
private class AggregateCreateOrUpdateCommandHandler implements MessageHandler<CommandMessage<?>> {
private final MessageHandlingMember<? super DynamicAggregate> handler;
private final DynamicCommandProcessor dynamicCommandProcessor;
private final String aggregateType;
public AggregateCreateOrUpdateCommandHandler(
MessageHandlingMember<? super DynamicAggregate> handler,
DynamicCommandProcessor dynamicCommandProcessor,
String aggregateType
) {
this.handler = handler;
this.dynamicCommandProcessor = dynamicCommandProcessor;
this.aggregateType = aggregateType;
}
@Override
public Object handle(CommandMessage<?> command) throws Exception {
VersionedAggregateIdentifier iv = commandTargetResolver.resolveTarget(command);
return repository.loadOrCreate(
iv.getIdentifier(),
() -> new DynamicAggregate(this.dynamicCommandProcessor, this.aggregateType)
).handle(command);
}
@Override
public boolean canHandle(CommandMessage<?> message) {
return handler.canHandle(message);
}
}
private class AggregateCommandHandler implements MessageHandler<CommandMessage<?>> {
private final MessageHandlingMember<? super DynamicAggregate> handler;
public AggregateCommandHandler(MessageHandlingMember<? super DynamicAggregate> handler) {
this.handler = handler;
}
@Override
public Object handle(CommandMessage<?> command) throws Exception {
var identifier = commandTargetResolver.resolveTarget(command);
Aggregate<DynamicAggregate> aggregate;
try {
aggregate = repository.load(identifier.getIdentifier(), identifier.getVersion());
} catch (AggregateNotFoundException e) {
throw new AggregateNotFoundException(
identifier.getIdentifier(),
String.format(
"Cannot handle command [%s] in aggregate [%s] with id [%s].%n%s%s",
command.getCommandName(),
dynamicAggregateModel.type(),
identifier.getIdentifier(),
"Command handler cannot construct new aggregate instance",
", but aggregate with such id was not found."
),
e
);
}
return aggregate.handle(command);
}
@Override
public boolean canHandle(CommandMessage<?> message) {
return handler.canHandle(message);
}
}
private static class UnknownDynamicCommandHandlerException extends RuntimeException {
public UnknownDynamicCommandHandlerException(String message) {
super(message);
}
public UnknownDynamicCommandHandlerException(String message, Throwable cause) {
super(message, cause);
}
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicAggregateConfiguration.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import java.util.ArrayList;
import java.util.List;
import org.axonframework.common.Registration;
import org.axonframework.common.caching.Cache;
import org.axonframework.common.lock.PessimisticLockFactory;
import org.axonframework.config.AggregateConfiguration;
import org.axonframework.config.Configuration;
import org.axonframework.eventsourcing.AggregateFactory;
import org.axonframework.eventsourcing.EventSourcingRepository;
import org.axonframework.eventsourcing.SnapshotTriggerDefinition;
import org.axonframework.eventsourcing.eventstore.EventStore;
import org.axonframework.eventsourcing.snapshotting.SnapshotFilter;
import org.axonframework.lifecycle.Phase;
import org.axonframework.messaging.annotation.ParameterResolverFactory;
import org.axonframework.modelling.command.CommandTargetResolver;
import org.axonframework.modelling.command.Repository;
import org.axonframework.modelling.command.RepositoryProvider;
import org.axonframework.tracing.SpanFactory;
public class DynamicAggregateConfiguration implements AggregateConfiguration<DynamicAggregate> {
private final DynamicCommandProcessor dynamicCommandProcessor;
private final EventStore eventStore;
private final SnapshotTriggerDefinition snapshotTriggerDefinition;
private final SnapshotFilter snapshotFilter;
private final RepositoryProvider repositoryProvider;
private final SpanFactory spanFactory;
private final Cache cache;
private final ParameterResolverFactory parameterResolverFactory;
private final DynamicAggregateModel dynamicAggregateModel;
private final DynamicAggregateFactory dynamicAggregateFactory;
private final List<Registration> registrations = new ArrayList<>();
private final Repository<DynamicAggregate> repository;
private final DynamicAggregateCommandHandler dynamicAggregateCommandHandler;
private boolean addedAtRuntime = false;
private volatile boolean isSubscribed = false;
public DynamicAggregateConfiguration(
DynamicCommandProcessor dynamicCommandProcessor,
EventStore eventStore,
SnapshotTriggerDefinition snapshotTriggerDefinition,
SnapshotFilter snapshotFilter,
RepositoryProvider repositoryProvider,
SpanFactory spanFactory,
Cache cache,
ParameterResolverFactory parameterResolverFactory,
CommandTargetResolver commandTargetResolver,
DynamicAggregateModel dynamicAggregateModel
) {
this.dynamicCommandProcessor = dynamicCommandProcessor;
this.eventStore = eventStore;
this.snapshotTriggerDefinition = snapshotTriggerDefinition;
this.snapshotFilter = snapshotFilter;
this.repositoryProvider = repositoryProvider;
this.spanFactory = spanFactory;
this.cache = cache;
this.parameterResolverFactory = parameterResolverFactory;
this.dynamicAggregateModel = dynamicAggregateModel;
this.dynamicAggregateFactory = new DynamicAggregateFactory(this.dynamicCommandProcessor, dynamicAggregateModel);
this.repository = EventSourcingRepository.builder(DynamicAggregate.class)
.aggregateModel(this.dynamicAggregateModel)
.lockFactory(PessimisticLockFactory.usingDefaults())
.eventStore(this.eventStore)
.snapshotTriggerDefinition(snapshotTriggerDefinition)
.aggregateFactory(this.dynamicAggregateFactory)
.repositoryProvider(this.repositoryProvider)
.spanFactory(this.spanFactory)
.cache(this.cache)
.build();
this.dynamicAggregateCommandHandler = new DynamicAggregateCommandHandler.Builder()
.aggregateModel(dynamicAggregateModel)
.repository(this.repository)
.parameterResolverFactory(this.parameterResolverFactory)
.dynamicCommandProcessor(this.dynamicCommandProcessor)
.commandTargetResolver(commandTargetResolver)
.build();
}
@Override
public Repository<DynamicAggregate> repository() {
return this.repository;
}
@Override
public Class<DynamicAggregate> aggregateType() {
return DynamicAggregate.class;
}
@Override
public AggregateFactory<DynamicAggregate> aggregateFactory() {
return this.dynamicAggregateFactory;
}
@Override
public SnapshotFilter snapshotFilter() {
return this.snapshotFilter;
}
@Override
public void initialize(Configuration config) {
if (this.addedAtRuntime && !this.isSubscribed) {
this.registrations.add(
dynamicAggregateCommandHandler.subscribe(config.commandBus())
);
this.isSubscribed = true;
} else {
config.onStart(
Phase.LOCAL_MESSAGE_HANDLER_REGISTRATIONS,
() -> {
//TODO: We need to find out why the callback gets registered twice to the configuration (DefaultConfigurer:867)
if (!this.isSubscribed) {
this.isSubscribed = true;
registrations.add(
dynamicAggregateCommandHandler.subscribe(config.commandBus())
);
}
}
);
}
config.onShutdown(
Phase.LOCAL_MESSAGE_HANDLER_REGISTRATIONS,
() -> {
registrations.forEach(Registration::cancel);
registrations.clear();
}
);
}
public void setAsAddedAtRuntime() {
this.addedAtRuntime = true;
}
public String getAggregateType() {
return this.dynamicAggregateModel.type();
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicAggregateConfigurationsProvider.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.axonsystem.dynamic.aggregate.exceptions.CannotProvideDynamicAggregateConfiguration;
import java.util.List;
public interface DynamicAggregateConfigurationsProvider {
List<DynamicAggregateConfiguration> provide();
DynamicAggregateConfiguration provide(String aggregateType)
throws CannotProvideDynamicAggregateConfiguration;
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicAggregateConfigurer.java | package ai.stapi.axonsystem.dynamic.aggregate;
import java.util.ArrayList;
import java.util.List;
import org.axonframework.config.Configurer;
import org.axonframework.config.ConfigurerModule;
import org.jetbrains.annotations.NotNull;
public class DynamicAggregateConfigurer implements ConfigurerModule {
private final DynamicAggregateConfigurationsProvider dynamicAggregateConfigurationsProvider;
private final RuntimeDynamicAggregateConfigurer runtimeDynamicAggregateConfigurer;
private final List<String> configuredAggregates;
public DynamicAggregateConfigurer(
DynamicAggregateConfigurationsProvider dynamicAggregateConfigurationsProvider,
RuntimeDynamicAggregateConfigurer runtimeDynamicAggregateConfigurer
) {
this.dynamicAggregateConfigurationsProvider = dynamicAggregateConfigurationsProvider;
this.runtimeDynamicAggregateConfigurer = runtimeDynamicAggregateConfigurer;
this.configuredAggregates = new ArrayList<>();
}
@Override
public void configureModule(@NotNull Configurer configurer) {
var aggregateConfigurations = this.dynamicAggregateConfigurationsProvider.provide();
aggregateConfigurations.forEach(configuration -> {
configurer.configureAggregate(configuration);
var aggregateClass = configuration.aggregateType();
if (aggregateClass.equals(DynamicAggregate.class)) {
this.configuredAggregates.add(configuration.getAggregateType());
} else {
this.configuredAggregates.add(aggregateClass.getCanonicalName());
}
});
}
public void configureNewAggregates() {
var currentConfigs = this.dynamicAggregateConfigurationsProvider.provide();
currentConfigs.stream()
.filter(config -> !this.configuredAggregates.contains(config.getAggregateType()))
.forEach(this.runtimeDynamicAggregateConfigurer::add);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicAggregateFactory.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import org.axonframework.eventhandling.DomainEventMessage;
import org.axonframework.eventsourcing.AbstractAggregateFactory;
public class DynamicAggregateFactory extends AbstractAggregateFactory<DynamicAggregate> {
private final DynamicCommandProcessor dynamicCommandProcessor;
public DynamicAggregateFactory(
DynamicCommandProcessor dynamicCommandProcessor,
DynamicAggregateModel dynamicAggregateModel
) {
super(dynamicAggregateModel);
this.dynamicCommandProcessor = dynamicCommandProcessor;
}
@Override
protected DynamicAggregate doCreateAggregate(
String aggregateIdentifier,
DomainEventMessage firstEvent
) {
return new DynamicAggregate(this.dynamicCommandProcessor, firstEvent.getType());
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicAggregateModel.java | package ai.stapi.axonsystem.dynamic.aggregate;
import static java.lang.String.format;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;
import org.axonframework.commandhandling.CommandMessageHandlingMember;
import org.axonframework.eventhandling.EventMessage;
import org.axonframework.messaging.Message;
import org.axonframework.messaging.annotation.MessageHandlerInvocationException;
import org.axonframework.messaging.annotation.MessageHandlingMember;
import org.axonframework.messaging.annotation.MessageInterceptingMember;
import org.axonframework.modelling.command.inspection.AggregateModel;
import org.axonframework.modelling.command.inspection.EntityModel;
public class DynamicAggregateModel implements AggregateModel<DynamicAggregate> {
private final String aggregateType;
private final Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>>
allCommandHandlerInterceptors;
private final Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>>
allCommandHandlers;
private final Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>>
allEventHandlers;
public DynamicAggregateModel(
String aggregateType,
Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>> allCommandHandlerInterceptors,
Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>> allCommandHandlers,
Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>> allEventHandlers
) {
this.aggregateType = aggregateType;
this.allCommandHandlerInterceptors = allCommandHandlerInterceptors;
this.allCommandHandlers = allCommandHandlers;
this.allEventHandlers = allEventHandlers;
}
@Override
public String type() {
return this.aggregateType;
}
@Override
public Long getVersion(DynamicAggregate dynamicAggregate) {
return dynamicAggregate.getVersion();
}
@Override
public Object getIdentifier(DynamicAggregate dynamicAggregate) {
return dynamicAggregate.getIdentity();
}
@Override
public String routingKey() {
return "identity";
}
@Override
public void publish(
EventMessage<?> eventMessage,
DynamicAggregate dynamicAggregate
) {
this.getHandler(eventMessage).ifPresent(h -> {
try {
//TODO: make chained interceptors, see HandlerInspector in regular model
h.handle(eventMessage, dynamicAggregate);
} catch (Exception e) {
String eventName;
if (eventMessage.getPayloadType().equals(DynamicGraphUpdatedEvent.class)) {
var payload = (DynamicGraphUpdatedEvent) eventMessage.getPayload();
eventName = payload.getEventName();
} else {
eventName = eventMessage.getPayloadType().toString();
}
throw new MessageHandlerInvocationException(
format(
"Error handling event of type [%s] in aggregate [%s] with id [%s]",
eventName,
this.aggregateType,
this.getIdentifier(dynamicAggregate)
),
e
);
}
});
}
@Override
public <C> EntityModel<C> modelOf(Class<? extends C> childEntityType) {
throw new RuntimeException("Dynamic Aggregate model cannot create other models.");
}
@Override
public Class<? extends DynamicAggregate> entityClass() {
return DynamicAggregate.class;
}
@Override
public Optional<Class<?>> type(String declaredType) {
if (declaredType.equals(this.aggregateType)) {
return Optional.of(DynamicAggregate.class);
}
return Optional.empty();
}
@Override
public Optional<String> declaredType(Class<?> type) {
return Optional.of(this.aggregateType);
}
@Override
public Stream<Class<?>> types() {
return Stream.of(DynamicAggregate.class);
}
@Override
public Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>> allCommandHandlers() {
return Collections.unmodifiableMap(this.allCommandHandlers);
}
@Override
public Stream<MessageHandlingMember<? super DynamicAggregate>> commandHandlers(
Class<? extends DynamicAggregate> type
) {
return this.filterHandlers(this.allCommandHandlers, type);
}
@Override
public Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>> allCommandHandlerInterceptors() {
return Collections.unmodifiableMap(this.allCommandHandlerInterceptors);
}
@Override
public Stream<MessageHandlingMember<? super DynamicAggregate>> commandHandlerInterceptors(
Class<? extends DynamicAggregate> type
) {
return this.filterHandlers(this.allCommandHandlerInterceptors, type);
}
@Override
public Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>> allEventHandlers() {
return Collections.unmodifiableMap(this.allEventHandlers);
}
private Optional<MessageHandlingMember<? super DynamicAggregate>> getHandler(Message<?> message) {
return this.filterHandlers(this.allEventHandlers, DynamicAggregate.class)
.filter(handler -> handler.canHandle(message))
.findFirst();
}
private Stream<MessageHandlingMember<? super DynamicAggregate>> filterHandlers(
Map<Class<?>, List<MessageHandlingMember<? super DynamicAggregate>>> handlers,
Class<?> subtype
) {
Class<?> type = subtype;
while (!handlers.containsKey(type) && !Objects.equals(type, Object.class)
&& type.getSuperclass() != null) {
type = type.getSuperclass();
}
return handlers.getOrDefault(type, Collections.emptyList()).stream();
}
public static class Builder {
private final String aggregateType;
private final List<MessageHandlingMember<? super DynamicAggregate>>
allCommandHandlerInterceptors;
private final List<MessageHandlingMember<? super DynamicAggregate>> allCommandHandlers;
private final List<MessageHandlingMember<? super DynamicAggregate>> allEventHandlers;
public Builder(String aggregateType) {
this.aggregateType = aggregateType;
this.allCommandHandlerInterceptors = new ArrayList<>();
this.allCommandHandlers = new ArrayList<>();
this.allEventHandlers = new ArrayList<>();
}
public Builder addCommandHandler(
CommandMessageHandlingMember<? super DynamicAggregate> commandHandler
) {
this.allCommandHandlers.add(commandHandler);
return this;
}
public Builder addCommandHandlerInterceptor(
MessageInterceptingMember<? super DynamicAggregate> commandHandlerInterceptor
) {
this.allCommandHandlerInterceptors.add(commandHandlerInterceptor);
return this;
}
public Builder addEventHandler(
MessageHandlingMember<? super DynamicAggregate> eventHandler
) {
this.allEventHandlers.add(eventHandler);
return this;
}
public DynamicAggregateModel build() {
return new DynamicAggregateModel(
this.aggregateType,
new HashMap<>(Map.of(DynamicAggregate.class, this.allCommandHandlerInterceptors)),
new HashMap<>(Map.of(DynamicAggregate.class, this.allCommandHandlers)),
new HashMap<>(Map.of(DynamicAggregate.class, this.allEventHandlers))
);
}
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicCommandMessageHandlerMember.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import java.lang.annotation.Annotation;
import java.util.Map;
import java.util.Optional;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.commandhandling.CommandMessageHandlingMember;
import org.axonframework.messaging.Message;
import org.jetbrains.annotations.NotNull;
public abstract class DynamicCommandMessageHandlerMember implements CommandMessageHandlingMember<DynamicAggregate> {
protected final DynamicCommandProcessor dynamicCommandProcessor;
protected final String aggregateType;
private final String commandName;
protected DynamicCommandMessageHandlerMember(
DynamicCommandProcessor dynamicCommandProcessor,
String aggregateType,
String commandName
) {
this.commandName = commandName;
this.aggregateType = aggregateType;
this.dynamicCommandProcessor = dynamicCommandProcessor;
}
@Override
public String commandName() {
return this.commandName;
}
@Override
public String routingKey() {
return DynamicCommand.TARGET_IDENTIFIER_FIELD_NAME;
}
@Override
public Class<?> payloadType() {
return DynamicCommand.class;
}
@Override
public boolean canHandle(@NotNull Message<?> message) {
if (!(message instanceof CommandMessage<?> commandMessage)) {
return false;
}
if (!(commandMessage.getPayload() instanceof DynamicCommand dynamicCommand)) {
return false;
}
return dynamicCommand.getSerializationType().equals(this.commandName);
}
@Override
public boolean canHandleMessageType(@NotNull Class<? extends Message> messageType) {
return messageType.isAssignableFrom(DynamicCommand.class);
}
@Override
@Deprecated
public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
return false;
}
@Override
@Deprecated
public Optional<Map<String, Object>> annotationAttributes(
Class<? extends Annotation> annotationType) {
return Optional.empty();
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicConstructorCommandMessageHandlerMember.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import java.lang.reflect.Constructor;
import java.util.Optional;
import org.axonframework.messaging.Message;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class DynamicConstructorCommandMessageHandlerMember extends DynamicCommandMessageHandlerMember {
public DynamicConstructorCommandMessageHandlerMember(
DynamicCommandProcessor dynamicCommandProcessor,
String aggregateType,
String commandName
) {
super(dynamicCommandProcessor, aggregateType, commandName);
}
@Override
public boolean isFactoryHandler() {
return true;
}
@Override
public Object handle(
@NotNull Message<?> message,
@Nullable DynamicAggregate target
) throws Exception {
return new DynamicAggregate(
this.dynamicCommandProcessor,
this.aggregateType,
(DynamicCommand) message.getPayload()
);
}
@Override
public <HT> Optional<HT> unwrap(Class<HT> handlerType) {
if (handlerType.isAssignableFrom(Constructor.class)) {
try {
return Optional.of(
(HT) DynamicAggregate.class.getConstructor(DynamicCommandProcessor.class, String.class)
);
} catch (NoSuchMethodException e) {
return Optional.empty();
}
}
if (handlerType.isAssignableFrom(this.getClass())) {
return Optional.of((HT) this);
}
return Optional.empty();
}
} |
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicCreateIfMissingCommandMessageHandlerMember.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Optional;
import org.axonframework.messaging.Message;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class DynamicCreateIfMissingCommandMessageHandlerMember extends DynamicCommandMessageHandlerMember {
public DynamicCreateIfMissingCommandMessageHandlerMember(
DynamicCommandProcessor dynamicCommandProcessor,
String aggregateType,
String commandName
) {
super(dynamicCommandProcessor, aggregateType, commandName);
}
@Override
public boolean isFactoryHandler() {
return true;
}
@Override
public Object handle(
@NotNull Message<?> message,
@Nullable DynamicAggregate target
) throws Exception {
if (target == null) {
return new DynamicAggregate(
this.dynamicCommandProcessor,
this.aggregateType,
(DynamicCommand) message.getPayload()
);
}
target.handle((DynamicCommand) message.getPayload());
return null;
}
@Override
public <HT> Optional<HT> unwrap(Class<HT> handlerType) {
if (handlerType.isAssignableFrom(Method.class)) {
try {
return Optional.of((HT) DynamicAggregate.class.getMethod("handle", DynamicCommand.class));
} catch (NoSuchMethodException e) {
return Optional.empty();
}
}
if (handlerType.isAssignableFrom(Constructor.class)) {
try {
return Optional.of(
(HT) DynamicAggregate.class.getConstructor(DynamicCommandProcessor.class, String.class)
);
} catch (NoSuchMethodException e) {
return Optional.empty();
}
}
if (handlerType.isAssignableFrom(this.getClass())) {
return Optional.of((HT) this);
}
return Optional.empty();
}
} |
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/DynamicMethodCommandMessageHandlerMember.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import java.lang.reflect.Method;
import java.util.Objects;
import java.util.Optional;
import org.axonframework.messaging.Message;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class DynamicMethodCommandMessageHandlerMember extends DynamicCommandMessageHandlerMember {
public DynamicMethodCommandMessageHandlerMember(
DynamicCommandProcessor dynamicCommandProcessor,
String aggregateType,
String commandName
) {
super(dynamicCommandProcessor, aggregateType, commandName);
}
@Override
public boolean isFactoryHandler() {
return false;
}
@Override
public Object handle(
@NotNull Message<?> message,
@Nullable DynamicAggregate target
) throws Exception {
Objects.requireNonNull(target).handle((DynamicCommand) message.getPayload());
return null;
}
@Override
public <HT> Optional<HT> unwrap(Class<HT> handlerType) {
if (handlerType.isAssignableFrom(Method.class)) {
try {
return Optional.of((HT) DynamicAggregate.class.getMethod("handle", DynamicCommand.class));
} catch (NoSuchMethodException e) {
return Optional.empty();
}
}
if (handlerType.isAssignableFrom(this.getClass())) {
return Optional.of((HT) this);
}
return Optional.empty();
}
} |
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/RuntimeDynamicAggregateConfigurer.java | package ai.stapi.axonsystem.dynamic.aggregate;
import ai.stapi.axonsystem.dynamic.aggregate.exceptions.CannotProvideDynamicAggregateConfiguration;
import ai.stapi.schema.structureSchema.exception.StructureSchemaException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.axonframework.config.Configurer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class RuntimeDynamicAggregateConfigurer {
private final DynamicAggregateConfigurationsProvider dynamicAggregateConfigurationsProvider;
private final Configurer configurer;
private final Map<String, List<String>> failedAddedAggregateDefinitions;
private final Logger logger;
public RuntimeDynamicAggregateConfigurer(
DynamicAggregateConfigurationsProvider dynamicAggregateConfigurationsProvider,
Configurer configurer
) {
this.dynamicAggregateConfigurationsProvider = dynamicAggregateConfigurationsProvider;
this.configurer = configurer;
this.logger = LoggerFactory.getLogger(RuntimeDynamicAggregateConfigurer.class);
this.failedAddedAggregateDefinitions = new HashMap<>();
}
public void add(String aggregateType) {
DynamicAggregateConfiguration aggregateDefinition;
try {
aggregateDefinition = this.dynamicAggregateConfigurationsProvider.provide(aggregateType);
} catch (CannotProvideDynamicAggregateConfiguration e) {
throw new RuntimeException("Cannot Configure Dynamic Aggregate at runtime.", e);
}
this.add(aggregateDefinition);
}
public void add(DynamicAggregateConfiguration aggregateDefinition) {
var aggregateType = aggregateDefinition.getAggregateType();
try {
aggregateDefinition.setAsAddedAtRuntime();
this.configurer.configureAggregate(aggregateDefinition);
var message = "New aggregate added at runtime: [%s]".formatted(aggregateType);
this.logger.info(message);
this.tryToConfigureFailed(aggregateType);
} catch (StructureSchemaException exception) {
var missingSerializationType = exception.getParentDefinitionType();
this.addToFailedTypes(aggregateType, missingSerializationType);
}
}
public void tryToConfigureFailed(String successfullyAddedType) {
if (this.failedAddedAggregateDefinitions.containsKey(successfullyAddedType)) {
var previouslyFailed = this.failedAddedAggregateDefinitions.get(successfullyAddedType);
this.failedAddedAggregateDefinitions.put(successfullyAddedType, new ArrayList<>());
previouslyFailed.forEach(this::add);
}
}
public Map<String, List<String>> getFailedAddedAggregateDefinitions() {
return failedAddedAggregateDefinitions;
}
private void addToFailedTypes(String aggregateType, String missingType) {
this.failedAddedAggregateDefinitions.computeIfAbsent(
missingType,
key -> new ArrayList<>()
).add(aggregateType);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/exceptions/CannotProvideDynamicAggregateConfiguration.java | package ai.stapi.axonsystem.dynamic.aggregate.exceptions;
public class CannotProvideDynamicAggregateConfiguration extends Exception {
public CannotProvideDynamicAggregateConfiguration(String aggregateType) {
super(
String.format(
"Cannot provide Dynamic Aggregate Configuration for '%s', because it does not exists.",
aggregateType
)
);
}
public CannotProvideDynamicAggregateConfiguration(String aggregateType, Throwable cause) {
super(
String.format(
"Cannot provide Dynamic Aggregate Configuration for '%s', because it does not exists.\n Cause: %s",
aggregateType,
cause.getMessage()
),
cause
);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/aggregate/exceptions/CannotProvideDynamicAggregateConfigurationFromAggregateDefinition.java | package ai.stapi.axonsystem.dynamic.aggregate.exceptions;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
public class CannotProvideDynamicAggregateConfigurationFromAggregateDefinition
extends RuntimeException {
private CannotProvideDynamicAggregateConfigurationFromAggregateDefinition(String becauseMessage) {
super("Cannot provide DynamicAggregateConfiguration from OperationDefinition, because "
+ becauseMessage);
}
public static CannotProvideDynamicAggregateConfigurationFromAggregateDefinition becauseOperationHasNoneOrMoreResources(
OperationDefinitionDTO operationDefinitionDTO
) {
return new CannotProvideDynamicAggregateConfigurationFromAggregateDefinition(
"operation definition has none or more resources." +
"\nOperation definition: " + operationDefinitionDTO
);
}
public static CannotProvideDynamicAggregateConfigurationFromAggregateDefinition becauseCommandHandlerDefinitionHasUnknownCreationalPolicy(
CommandHandlerDefinitionDTO commandDefinition
) {
return new CannotProvideDynamicAggregateConfigurationFromAggregateDefinition(
"command handler definition has unknown creational policy." +
"\nCommand handler definition: " + commandDefinition
);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/command/CustomCommandTargetResolver.java | package ai.stapi.axonsystem.dynamic.command;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.modelling.command.AnnotationCommandTargetResolver;
import org.axonframework.modelling.command.CommandTargetResolver;
import org.axonframework.modelling.command.VersionedAggregateIdentifier;
import org.jetbrains.annotations.NotNull;
public class CustomCommandTargetResolver implements CommandTargetResolver {
private final AnnotationCommandTargetResolver annotationCommandTargetResolver;
public CustomCommandTargetResolver() {
this.annotationCommandTargetResolver = AnnotationCommandTargetResolver.builder().build();
}
@Override
public VersionedAggregateIdentifier resolveTarget(@NotNull CommandMessage<?> command) {
var payload = command.getPayload();
if (payload instanceof AbstractCommand<?> abstractCommand) {
return new VersionedAggregateIdentifier(
abstractCommand.getTargetIdentifier(),
null
);
}
return this.annotationCommandTargetResolver.resolveTarget(command);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/command/DynamicCommandDispatchInterceptor.java | package ai.stapi.axonsystem.dynamic.command;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import java.util.List;
import java.util.function.BiFunction;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.commandhandling.GenericCommandMessage;
import org.axonframework.messaging.GenericMessage;
import org.axonframework.messaging.MessageDispatchInterceptor;
import org.jetbrains.annotations.NotNull;
public class DynamicCommandDispatchInterceptor implements MessageDispatchInterceptor<CommandMessage<?>> {
@NotNull
@Override
public BiFunction<Integer, CommandMessage<?>, CommandMessage<?>> handle(
@NotNull List<? extends CommandMessage<?>> messages
) {
return (integer, commandMessage) -> {
if (commandMessage.getPayload() instanceof DynamicCommand dynamicCommand) {
return new GenericCommandMessage<>(
new GenericMessage<>(dynamicCommand, commandMessage.getMetaData()),
dynamicCommand.getSerializationType()
);
}
return commandMessage;
};
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/event/DynamicEventHandler.java | package ai.stapi.axonsystem.dynamic.event;
import ai.stapi.axonsystem.dynamic.messagehandler.DynamicMessageHandler;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.axonframework.eventhandling.EventMessage;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.METHOD})
@DynamicMessageHandler(
messageType = EventMessage.class,
payloadType = DynamicGraphUpdatedEvent.class
)
public @interface DynamicEventHandler {
/**
* Specifies the name of message that can be handled by the member method.
*/
String messageName();
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/messagehandler/DynamicMessageHandler.java | package ai.stapi.axonsystem.dynamic.messagehandler;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.axonframework.messaging.Message;
import org.axonframework.messaging.annotation.HasHandlerAttributes;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.METHOD})
@HasHandlerAttributes
public @interface DynamicMessageHandler {
/**
* Specifies the type of message that can be handled by the member method. Defaults to any
* {@link Message}.
*/
Class<? extends Message> messageType() default Message.class;
/**
* Specifies the type of message payload that can be handled by the member method. The payload of
* the message should be assignable to this type. Defaults to any {@link Object}.
*/
Class<?> payloadType() default Object.class;
/**
* Specifies the name of message payload that can be handled by the member method.
*/
String messageName() default "";
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/messagehandler/DynamicMessageHandlerLookup.java | package ai.stapi.axonsystem.dynamic.messagehandler;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.axonframework.common.ObjectUtils;
import org.axonframework.common.ReflectionUtils;
import org.axonframework.common.annotation.AnnotationUtils;
import org.axonframework.messaging.Message;
import org.axonframework.messaging.annotation.MessageHandler;
import org.axonframework.spring.config.MessageHandlerConfigurer;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.OrderUtils;
public class DynamicMessageHandlerLookup implements BeanDefinitionRegistryPostProcessor {
private static final Logger logger = Logger.getLogger(
DynamicMessageHandlerLookup.class.getSimpleName()
);
public static List<String> messageHandlerBeans(Class<? extends Message<?>> messageType,
ConfigurableListableBeanFactory registry) {
return messageHandlerBeans(messageType, registry, false);
}
public static List<String> messageHandlerBeans(Class<? extends Message<?>> messageType,
ConfigurableListableBeanFactory registry,
boolean includePrototypeBeans) {
List<String> found = new ArrayList<>();
for (String beanName : registry.getBeanDefinitionNames()) {
BeanDefinition bd = registry.getBeanDefinition(beanName);
if (includePrototypeBeans || (bd.isSingleton() && !bd.isAbstract())) {
Class<?> beanType = registry.getType(beanName);
if (beanType != null && shouldBeRegistered(messageType, beanType)) {
found.add(beanName);
}
}
}
return found;
}
private static boolean shouldBeRegistered(
Class<? extends Message<?>> messageType,
Class<?> beanType
) {
var hasDynamic = false;
for (Method m : ReflectionUtils.methodsOf(beanType)) {
var normalAttr = AnnotationUtils.findAnnotationAttributes(m, MessageHandler.class);
if (normalAttr.isPresent()) {
return false;
}
var dynamicAttr = AnnotationUtils.findAnnotationAttributes(m, DynamicMessageHandler.class);
if (
dynamicAttr.isPresent() && messageType.isAssignableFrom(
(Class<?>) dynamicAttr.get().get("messageType"))
) {
hasDynamic = true;
}
}
return hasDynamic;
}
@Override
public void postProcessBeanFactory(@Nonnull ConfigurableListableBeanFactory beanFactory)
throws BeansException {
if (!(beanFactory instanceof BeanDefinitionRegistry)) {
logger.warning(
"Given bean factory is not a BeanDefinitionRegistry. Cannot auto-configure message handlers"
);
return;
}
for (MessageHandlerConfigurer.Type value : MessageHandlerConfigurer.Type.values()) {
String configurerBeanName = "DynamicMessageHandlerConfigurer$$Axon$$" + value.name();
if (beanFactory.containsBeanDefinition(configurerBeanName)) {
logger.info("Dynamic message handler configurer already available. Skipping configuration");
break;
}
List<String> found = messageHandlerBeans(value.getMessageType(), beanFactory);
if (!found.isEmpty()) {
List<String> sortedFound = sortByOrder(found, beanFactory);
AbstractBeanDefinition beanDefinition =
BeanDefinitionBuilder.genericBeanDefinition(MessageHandlerConfigurer.class)
.addConstructorArgValue(value.name())
.addConstructorArgValue(sortedFound)
.getBeanDefinition();
((BeanDefinitionRegistry) beanFactory).registerBeanDefinition(configurerBeanName,
beanDefinition);
}
}
}
private List<String> sortByOrder(List<String> found,
@Nonnull ConfigurableListableBeanFactory beanFactory) {
return found.stream()
.collect(Collectors.toMap(
beanRef -> beanRef,
beanRef -> OrderUtils.getOrder(
ObjectUtils.getOrDefault(beanFactory.getType(beanRef), Object.class),
Ordered.LOWEST_PRECEDENCE
)
))
.entrySet()
.stream()
.sorted(java.util.Map.Entry.comparingByValue())
.map(java.util.Map.Entry::getKey)
.collect(Collectors.toList());
}
@Override
public void postProcessBeanDefinitionRegistry(@Nonnull BeanDefinitionRegistry registry)
throws BeansException {
// No action required.
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/messagehandler/DynamicMessageHandlingMember.java | package ai.stapi.axonsystem.dynamic.messagehandler;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import java.lang.annotation.Annotation;
import java.lang.reflect.Executable;
import java.util.Map;
import java.util.Optional;
import org.axonframework.messaging.Message;
import org.axonframework.messaging.annotation.AnnotatedMessageHandlingMember;
import org.axonframework.messaging.annotation.MessageHandlingMember;
import org.axonframework.messaging.annotation.ParameterResolverFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class DynamicMessageHandlingMember<T> implements MessageHandlingMember<T> {
private final AnnotatedMessageHandlingMember<T> annotatedMessageHandlingMember;
private final String messageName;
public DynamicMessageHandlingMember(
Executable executable,
Class<? extends Message<?>> messageType,
Class<?> explicitPayloadType,
ParameterResolverFactory parameterResolverFactory,
String messageName
) {
this.messageName = messageName;
this.annotatedMessageHandlingMember = new AnnotatedMessageHandlingMember<>(
executable,
messageType,
explicitPayloadType,
parameterResolverFactory
);
}
@Override
public Class<?> payloadType() {
return this.annotatedMessageHandlingMember.payloadType();
}
@Override
public boolean canHandle(@NotNull Message<?> message) {
if (!this.annotatedMessageHandlingMember.canHandle(message)) {
return false;
}
if (message.getPayloadType().equals(DynamicGraphUpdatedEvent.class)) {
var dynamicEvent = (DynamicGraphUpdatedEvent) message.getPayload();
return dynamicEvent.getEventName().equals(this.messageName);
}
//TODO: Same thing for query
return false;
}
@Override
public boolean canHandleMessageType(@NotNull Class<? extends Message> messageType) {
return this.annotatedMessageHandlingMember.canHandleMessageType(messageType);
}
@Override
public Object handle(@NotNull Message<?> message, @Nullable T target) throws Exception {
return this.annotatedMessageHandlingMember.handle(message, target);
}
@Override
public <HT> Optional<HT> unwrap(Class<HT> handlerType) {
return this.annotatedMessageHandlingMember.unwrap(handlerType);
}
@Override
@Deprecated
public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
return this.annotatedMessageHandlingMember.hasAnnotation(annotationType);
}
@Override
@Deprecated
public Optional<Map<String, Object>> annotationAttributes(
Class<? extends Annotation> annotationType) {
return this.annotatedMessageHandlingMember.annotationAttributes(annotationType);
}
@Override
public int priority() {
return this.annotatedMessageHandlingMember.priority();
}
@Override
public boolean canHandleType(@NotNull Class<?> payloadType) {
return this.annotatedMessageHandlingMember.canHandleType(payloadType);
}
@Override
public Class<?> declaringClass() {
return this.annotatedMessageHandlingMember.declaringClass();
}
@Override
public String signature() {
return this.annotatedMessageHandlingMember.signature();
}
@Override
public <R> Optional<R> attribute(String attributeKey) {
return this.annotatedMessageHandlingMember.attribute(attributeKey);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/dynamic/messagehandler/DynamicMessageHandlingMemberDefinition.java | package ai.stapi.axonsystem.dynamic.messagehandler;
import static org.axonframework.common.annotation.AnnotationUtils.findAnnotationAttributes;
import java.lang.reflect.Executable;
import java.util.Optional;
import javax.annotation.Nonnull;
import org.axonframework.messaging.Message;
import org.axonframework.messaging.annotation.HandlerDefinition;
import org.axonframework.messaging.annotation.MessageHandlingMember;
import org.axonframework.messaging.annotation.ParameterResolverFactory;
public class DynamicMessageHandlingMemberDefinition implements HandlerDefinition {
@Override
public <T> Optional<MessageHandlingMember<T>> createHandler(
@Nonnull Class<T> declaringType,
@Nonnull Executable executable,
@Nonnull ParameterResolverFactory parameterResolverFactory
) {
return findAnnotationAttributes(executable, DynamicMessageHandler.class).map(
attr -> new DynamicMessageHandlingMember<T>(
executable,
(Class<? extends Message<?>>) attr.getOrDefault("messageType", Message.class),
(Class<?>) attr.getOrDefault("payloadType", Object.class),
parameterResolverFactory,
(String) attr.get("messageName")
)
);
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/graphaggregate/AggregateWithDynamicGraph.java | package ai.stapi.axonsystem.graphaggregate;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import org.axonframework.modelling.command.AggregateIdentifier;
import org.axonframework.modelling.command.AggregateLifecycle;
import org.axonframework.modelling.command.AggregateVersion;
public abstract class AggregateWithDynamicGraph<T extends UniqueIdentifier> extends AggregateWithGraph {
@AggregateIdentifier
protected T identity;
@AggregateVersion
protected long version;
protected DynamicCommandProcessor commandProcessor;
protected AggregateWithDynamicGraph() {
}
protected AggregateWithDynamicGraph(DynamicCommandProcessor commandProcessor) {
this.commandProcessor = commandProcessor;
}
protected void processCommandDynamically(AbstractCommand<T> command) {
this.processCommandDynamically(command, MissingFieldResolvingStrategy.LENIENT);
}
protected void processCommandDynamically(
AbstractCommand<T> command,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
this.commandProcessor.processCommand(
command,
this.inMemoryGraphRepository.getGraph(),
missingFieldResolvingStrategy
).forEach(AggregateLifecycle::apply);
}
protected void onAggregateCreated(AggregateGraphUpdatedEvent<T> event) {
this.identity = event.getIdentity();
this.onEveryGraphEvent(event);
}
public T getIdentity() {
return identity;
}
public long getVersion() {
return version;
}
}
|
0 | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem | java-sources/ai/stapi/axon-system/0.2.3/ai/stapi/axonsystem/graphaggregate/AggregateWithGraph.java | package ai.stapi.axonsystem.graphaggregate;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graphsystem.messaging.event.GraphUpdatedEvent;
import org.axonframework.eventsourcing.EventSourcingHandler;
public abstract class AggregateWithGraph {
protected final InMemoryGraphRepository inMemoryGraphRepository = new InMemoryGraphRepository();
@EventSourcingHandler
public void onEveryGraphEvent(GraphUpdatedEvent event) {
this.inMemoryGraphRepository.removeGraphElements(
event.getGraphElementsForRemoval().toArray(new GraphElementForRemoval[0])
);
this.inMemoryGraphRepository.merge(event.getSynchronizedGraph());
}
public InMemoryGraphRepository getInMemoryGraphRepository() {
return inMemoryGraphRepository;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/DefaultGraphProjection.java | package ai.stapi.axonsystemplugin;
import ai.stapi.graph.EdgeRepository;
import ai.stapi.graph.NodeRepository;
import ai.stapi.graph.graphElementForRemoval.EdgeForRemoval;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.graphElementForRemoval.NodeForRemoval;
import ai.stapi.graphoperations.synchronization.GraphSynchronizer;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import ai.stapi.graphsystem.messaging.event.GraphUpdatedEvent;
import java.time.LocalDateTime;
import java.time.temporal.Temporal;
import java.util.concurrent.atomic.AtomicInteger;
import org.axonframework.eventhandling.EventHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DefaultGraphProjection {
private static final AtomicInteger lastEventIteration = new AtomicInteger(0);
private final NodeRepository nodeRepository;
private final EdgeRepository edgeRepository;
private final GraphSynchronizer graphSynchronizer;
private final Logger logger;
private Temporal lastEventTime;
public DefaultGraphProjection(
NodeRepository nodeRepository,
EdgeRepository edgeRepository,
GraphSynchronizer graphSynchronizer
) {
this.nodeRepository = nodeRepository;
this.edgeRepository = edgeRepository;
this.graphSynchronizer = graphSynchronizer;
this.logger = LoggerFactory.getLogger(DefaultGraphProjection.class);
this.lastEventTime = LocalDateTime.now();
}
@EventHandler
public void handle(GraphUpdatedEvent event) {
event.getGraphElementsForRemoval().forEach(this::removeGraphElement);
this.graphSynchronizer.synchronize(event.getSynchronizedGraph());
this.lastEventTime = LocalDateTime.now();
// var lastIteration = this.lastEventIteration.incrementAndGet();
String eventName;
if (event instanceof DynamicGraphUpdatedEvent dynamicGraphUpdatedEvent) {
eventName = dynamicGraphUpdatedEvent.getEventName();
} else {
eventName = event.getClass().getSimpleName();
}
String message;
if (event instanceof AggregateGraphUpdatedEvent<?> aggregateEvent) {
message = "Event [%s] of aggregate with id [%s] was synchronized.".formatted(
eventName,
aggregateEvent.getIdentity()
);
} else {
message = "Event [%s] was synchronized.".formatted(eventName);
}
this.logger.info(message);
}
private void removeGraphElement(GraphElementForRemoval graphElementForRemoval) {
if (graphElementForRemoval instanceof NodeForRemoval nodeForRemoval) {
nodeRepository.removeNode(
nodeForRemoval.getGraphElementId(),
nodeForRemoval.getGraphElementType()
);
}
if (graphElementForRemoval instanceof EdgeForRemoval edgeForRemoval) {
edgeRepository.removeEdge(
edgeForRemoval.getGraphElementId(),
edgeForRemoval.getGraphElementType()
);
}
}
public Temporal getLastEventTime() {
return lastEventTime;
}
public Integer getLastEventIteration() {
return lastEventIteration.get();
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition/CreateAggregateDefinitionPolicy.java | package ai.stapi.axonsystemplugin.aggregatedefinition;
import ai.stapi.axonsystemplugin.structuredefinition.configure.StructureDefinitionConfigured;
import ai.stapi.graphsystem.aggregatedefinition.model.ResourceAggregateDefinitionMapper;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchema.exception.FieldsNotFoundException;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.eventhandling.EventHandler;
public class CreateAggregateDefinitionPolicy {
private final CommandGateway commandGateway;
private final StructureSchemaFinder structureSchemaFinder;
private final ResourceAggregateDefinitionMapper aggregateDefinitionMapper;
private final ObjectMapper objectMapper;
public CreateAggregateDefinitionPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ResourceAggregateDefinitionMapper aggregateDefinitionMapper,
ObjectMapper objectMapper
) {
this.commandGateway = commandGateway;
this.structureSchemaFinder = structureSchemaFinder;
this.aggregateDefinitionMapper = aggregateDefinitionMapper;
this.objectMapper = objectMapper;
}
@EventHandler
public void on(StructureDefinitionConfigured event) {
if (!event.getKind().equals("resource")) {
return;
}
this.createAggregate(event.getStructureDefinitionId());
}
private void createAggregate(StructureDefinitionId structureId) {
var id = structureId.getId();
ResourceStructureType structureType;
try {
structureType = (ResourceStructureType) this.structureSchemaFinder.getStructureType(id);
} catch (FieldsNotFoundException e) {
throw new CannotCreateAggregateDefinition(
String.format(
"Cannot create automatic Aggregate Definition for '%s' resource. "
+ "Because there was no corresponding Structure Schema to be found.",
structureId
),
e
);
}
var aggregateDefinition = this.aggregateDefinitionMapper.map(structureType);
this.commandGateway.send(
new DynamicCommand(
new UniqueIdentifier(aggregateDefinition.getId()),
"CreateAggregateDefinition",
this.objectMapper.convertValue(
aggregateDefinition,
new TypeReference<>() {
}
)
)
);
}
private static class CannotCreateAggregateDefinition extends RuntimeException {
public CannotCreateAggregateDefinition(String message) {
super(message);
}
public CannotCreateAggregateDefinition(String message, Throwable cause) {
super(message, cause);
}
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition/createCRUDCommandHandlers/AbstractCreateCRUDCommandHandlerPolicy.java | package ai.stapi.axonsystemplugin.aggregatedefinition.createCRUDCommandHandlers;
import ai.stapi.axonsystem.dynamic.event.DynamicEventHandler;
import ai.stapi.axonsystemplugin.structuredefinition.configure.ElementsToStructureDefinitionConfigured;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.EventFactoryModificationResult;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.OperationEventFactoriesMapper;
import ai.stapi.graphsystem.eventdefinition.EventMessageDefinitionData;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.OperationDefinitionParameters;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.ResourceOperationsMapper;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchema.exception.FieldsNotFoundException;
import ai.stapi.schema.structureSchemaMapper.StructureDefinitionToSSMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.eventhandling.EventHandler;
import org.jetbrains.annotations.NotNull;
public abstract class AbstractCreateCRUDCommandHandlerPolicy {
private final CommandGateway commandGateway;
private final StructureSchemaFinder schemaFinder;
private final ObjectMapper objectMapper;
private final StructureDefinitionToSSMapper structureDefinitionToSSMapper;
protected AbstractCreateCRUDCommandHandlerPolicy(
CommandGateway commandGateway,
StructureSchemaFinder schemaFinder,
ObjectMapper objectMapper,
StructureDefinitionToSSMapper structureDefinitionToSSMapper
) {
this.commandGateway = commandGateway;
this.schemaFinder = schemaFinder;
this.objectMapper = objectMapper;
this.structureDefinitionToSSMapper = structureDefinitionToSSMapper;
}
protected abstract ResourceOperationsMapper resourceOperationsMapper();
protected abstract OperationEventFactoriesMapper operationEventDefinitionMapper();
protected abstract String creationalPolicy();
@DynamicEventHandler(messageName = "AggregateDefinitionCreated")
public void on(DynamicGraphUpdatedEvent event) {
var aggregateType = event.getSynchronizedGraph().traversable()
.loadNode(event.getIdentity(), "AggregateDefinition")
.getEdges("structure")
.get(0)
.getNodeTo()
.getId()
.getId();
var resourceStructureType = this.getResourceStructureType(aggregateType);
var operations = this.resourceOperationsMapper()
.map(resourceStructureType)
.getOperations();
this.handleNewOperations(event.getIdentity().getId(), operations);
}
@EventHandler
public void on(ElementsToStructureDefinitionConfigured event) {
var groupedByType = new HashMap<String, List<String>>();
event.getElementPaths().forEach(path -> {
var split = path.split("\\.");
if (split.length < 2) {
throw new RuntimeException("This should never happen.");
}
String modifiedType;
if (split.length == 2) {
modifiedType = split[0];
} else {
modifiedType =
this.structureDefinitionToSSMapper.createAnonymousComplexTypeNameFromElementPath(
String.join(
".",
Arrays.copyOfRange(split, 0, split.length - 1)
)
);
}
var fieldName = split[split.length - 1];
groupedByType.computeIfAbsent(modifiedType, key -> new ArrayList<>()).add(fieldName);
});
groupedByType.forEach((type, fieldNames) -> {
var structureType = (ComplexStructureType) this.schemaFinder.getStructureType(type);
var result = this.resourceOperationsMapper().mapNewFields(
structureType,
fieldNames
);
result.forEach((resourceId, subResult) -> {
this.handleNewOperations(resourceId, subResult.getOperations());
this.handleOperationChanges(resourceId, subResult.getNewParameters());
});
});
}
private void handleNewOperations(
String resourceId,
List<OperationDefinitionDTO> operations
) {
if (operations.isEmpty()) {
return;
}
operations.stream()
.map(this::createOperationDefinitionCommand)
.forEach(this.commandGateway::send);
var commandHandlers = new ArrayList<HashMap<String, Object>>();
operations.forEach(operation -> {
var eventFactories = this.operationEventDefinitionMapper().map(operation);
eventFactories.stream()
.map(eventFactory -> this.createEventDefinitionCommand(eventFactory.getEvent()))
.forEach(this.commandGateway::send);
var commandHandler = new HashMap<>(Map.of(
"operation", new HashMap<>(
Map.of(
"id", operation.getId()
)
),
"creationalPolicy", this.creationalPolicy(),
"eventFactory", eventFactories.stream().map(
eventFactory -> new HashMap<>(Map.of(
"id", eventFactory.getId(),
"event", new HashMap<>(Map.of(
"id", eventFactory.getEvent().getId()
)),
"modification", eventFactory.getModification().stream()
.map(modification -> this.objectMapper.convertValue(
modification,
HashMap.class
)).collect(Collectors.toList())
)
)).collect(Collectors.toList())
));
commandHandlers.add(commandHandler);
});
this.commandGateway.send(
new DynamicCommand(
new UniqueIdentifier(resourceId),
"AddCommandOnAggregateDefinition",
Map.of(
"command", commandHandlers
)
)
);
}
private void handleOperationChanges(
String resourceId,
List<OperationDefinitionParameters> newParameters
) {
newParameters.stream()
.filter(params -> !params.getParameters().isEmpty())
.map(this::createAddParameterCommand)
.forEach(this.commandGateway::send);
newParameters.stream()
.filter(params -> !params.getParameters().isEmpty())
.forEach(parameters -> {
var modifications = this.operationEventDefinitionMapper()
.mapParameters(parameters);
modifications.stream()
.map(result -> this.createAddModificationCommand(resourceId, result))
.forEach(this.commandGateway::send);
});
}
@NotNull
private DynamicCommand createOperationDefinitionCommand(OperationDefinitionDTO operation) {
return new DynamicCommand(
new UniqueIdentifier(operation.getId()),
"CreateOperationDefinition",
this.objectMapper.convertValue(operation, new TypeReference<>() {
})
);
}
@NotNull
private DynamicCommand createEventDefinitionCommand(EventMessageDefinitionData eventDefinition) {
return new DynamicCommand(
new UniqueIdentifier(eventDefinition.getId()),
"CreateEventMessageDefinition",
this.objectMapper.convertValue(eventDefinition, new TypeReference<>() {
})
);
}
private DynamicCommand createAddParameterCommand(
OperationDefinitionParameters operationDefinitionParameters
) {
return new DynamicCommand(
new UniqueIdentifier(operationDefinitionParameters.getOperationId()),
"AddParameterOnOperationDefinition",
Map.of(
"parameter", this.objectMapper.convertValue(
operationDefinitionParameters.getParameters(),
new TypeReference<List<HashMap<String, Object>>>() {
}
)
)
);
}
private DynamicCommand createAddModificationCommand(
String resourceId,
EventFactoryModificationResult result
) {
return new DynamicCommand(
new UniqueIdentifier(resourceId),
"AddModificationOnAggregateDefinitionCommandEventFactory",
Map.of(
"eventFactoryId", String.format("CommandHandlerDefinitionEventFactory/%s", result.getEventFactoryId()),
"modification", this.objectMapper.convertValue(
result.getEventFactoryModifications(),
new TypeReference<List<HashMap<String, Object>>>() {
}
)
)
);
}
private ResourceStructureType getResourceStructureType(String aggregateType) {
try {
return (ResourceStructureType) this.schemaFinder.getStructureType(aggregateType);
} catch (FieldsNotFoundException e) {
throw new CannotCreateAutomaticOperationForAggregate(
String.format(
"Cannot create automatic Operations for Aggregate '%s' with '%s', " +
"because related Structure Schema was not found.",
aggregateType,
this.resourceOperationsMapper().getClass().getCanonicalName()
),
e
);
}
}
private static class CannotCreateAutomaticOperationForAggregate extends RuntimeException {
public CannotCreateAutomaticOperationForAggregate(String message, Throwable cause) {
super(message, cause);
}
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition/createCRUDCommandHandlers/CreateAddItemCommandHandlerPolicy.java | package ai.stapi.axonsystemplugin.aggregatedefinition.createCRUDCommandHandlers;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.ItemAddedOperationEventFactoriesMapper;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.OperationEventFactoriesMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.AddItemOnResourceOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.ResourceOperationsMapper;
import ai.stapi.schema.structureSchemaMapper.StructureDefinitionToSSMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.axonframework.commandhandling.gateway.CommandGateway;
public class CreateAddItemCommandHandlerPolicy extends AbstractCreateCRUDCommandHandlerPolicy {
private final AddItemOnResourceOperationsMapper addItemOnResourceOperationsMapper;
private final ItemAddedOperationEventFactoriesMapper itemAddedOperationEventMessageMapper;
public CreateAddItemCommandHandlerPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper,
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
AddItemOnResourceOperationsMapper addItemOnResourceOperationsMapper,
ItemAddedOperationEventFactoriesMapper itemAddedOperationEventMessageMapper
) {
super(commandGateway, structureSchemaFinder, objectMapper, structureDefinitionToSSMapper);
this.addItemOnResourceOperationsMapper = addItemOnResourceOperationsMapper;
this.itemAddedOperationEventMessageMapper = itemAddedOperationEventMessageMapper;
}
@Override
protected ResourceOperationsMapper resourceOperationsMapper() {
return this.addItemOnResourceOperationsMapper;
}
@Override
protected OperationEventFactoriesMapper operationEventDefinitionMapper() {
return this.itemAddedOperationEventMessageMapper;
}
@Override
protected String creationalPolicy() {
return CommandHandlerDefinitionDTO.CreationPolicy.NEVER;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition/createCRUDCommandHandlers/CreateCreationalCommandHandlerPolicy.java | package ai.stapi.axonsystemplugin.aggregatedefinition.createCRUDCommandHandlers;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.CreationPolicy;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.CreatedOperationEventFactoriesMapper;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.OperationEventFactoriesMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.CreationalResourceOperationMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.ResourceOperationsMapper;
import ai.stapi.schema.structureSchemaMapper.StructureDefinitionToSSMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.axonframework.commandhandling.gateway.CommandGateway;
public class CreateCreationalCommandHandlerPolicy extends AbstractCreateCRUDCommandHandlerPolicy {
private final CreationalResourceOperationMapper creationalResourceOperationMapper;
private final CreatedOperationEventFactoriesMapper createdOperationEventDefinitionMapper;
public CreateCreationalCommandHandlerPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper,
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
CreationalResourceOperationMapper creationalResourceOperationMapper,
CreatedOperationEventFactoriesMapper createdOperationEventDefinitionMapper
) {
super(commandGateway, structureSchemaFinder, objectMapper, structureDefinitionToSSMapper);
this.creationalResourceOperationMapper = creationalResourceOperationMapper;
this.createdOperationEventDefinitionMapper = createdOperationEventDefinitionMapper;
}
@Override
protected ResourceOperationsMapper resourceOperationsMapper() {
return this.creationalResourceOperationMapper;
}
@Override
protected OperationEventFactoriesMapper operationEventDefinitionMapper() {
return this.createdOperationEventDefinitionMapper;
}
@Override
protected String creationalPolicy() {
return CreationPolicy.IF_MISSING;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/aggregatedefinition/createCRUDCommandHandlers/CreateUpdateCommandHandlerPolicy.java | package ai.stapi.axonsystemplugin.aggregatedefinition.createCRUDCommandHandlers;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.CreationPolicy;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.OperationEventFactoriesMapper;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.UpdatedOperationEventFactoriesMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.ResourceOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.UpdateResourceOperationMapper;
import ai.stapi.schema.structureSchemaMapper.StructureDefinitionToSSMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.axonframework.commandhandling.gateway.CommandGateway;
public class CreateUpdateCommandHandlerPolicy extends AbstractCreateCRUDCommandHandlerPolicy {
private final UpdateResourceOperationMapper updateResourceOperationMapper;
private final UpdatedOperationEventFactoriesMapper updatedOperationEventFactoriesMapper;
public CreateUpdateCommandHandlerPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper,
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
UpdateResourceOperationMapper updateResourceOperationMapper,
UpdatedOperationEventFactoriesMapper updatedOperationEventFactoriesMapper
) {
super(commandGateway, structureSchemaFinder, objectMapper, structureDefinitionToSSMapper);
this.updateResourceOperationMapper = updateResourceOperationMapper;
this.updatedOperationEventFactoriesMapper = updatedOperationEventFactoriesMapper;
}
@Override
protected ResourceOperationsMapper resourceOperationsMapper() {
return this.updateResourceOperationMapper;
}
@Override
protected OperationEventFactoriesMapper operationEventDefinitionMapper() {
return this.updatedOperationEventFactoriesMapper;
}
@Override
protected String creationalPolicy() {
return CreationPolicy.NEVER;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/commandpersisting/CommitCommandFixturesHandler.java | package ai.stapi.axonsystemplugin.commandpersisting;
import ai.stapi.axonsystem.commandpersisting.CommandFixturesCommitted;
import ai.stapi.axonsystem.commandpersisting.CommandMessageStore;
import ai.stapi.axonsystem.commandpersisting.CommitCommandFixtures;
import ai.stapi.axonsystem.commandpersisting.PersistedCommandMessage;
import ai.stapi.axonsystem.configuration.implementations.CommandDispatchedAtInterceptor;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.axonframework.commandhandling.CommandHandler;
import org.axonframework.eventhandling.gateway.EventGateway;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CommitCommandFixturesHandler {
private final SimpleDateFormat fileDateFormat = new SimpleDateFormat("yyMMddHHmmss");
private final CommandMessageStore commandMessageStore;
private final EventGateway eventGateway;
private final ObjectMapper objectMapper;
private final Logger logger;
public CommitCommandFixturesHandler(
CommandMessageStore commandMessageStore,
EventGateway eventGateway,
ObjectMapper objectMapper
) {
this.commandMessageStore = commandMessageStore;
this.eventGateway = eventGateway;
this.objectMapper = objectMapper;
this.logger = LoggerFactory.getLogger(CommitCommandFixturesHandler.class);
}
@CommandHandler
public void handle(CommitCommandFixtures command) throws IOException {
var messages = this.commandMessageStore.getAll();
var messagesByName = new HashMap<String, List<PersistedCommandMessage<?>>>();
messages.forEach(message -> {
var commandName = message.getCommandName();
if (!messagesByName.containsKey(commandName)) {
messagesByName.put(commandName, new ArrayList<>());
}
messagesByName.get(commandName).add(message);
});
for (var entry : messagesByName.entrySet()) {
var commandName = entry.getKey();
var directoryPath = command.getOutputDirectoryPath() + File.separator + commandName;
var directory = new File(directoryPath);
if (!directory.exists()) {
directory.mkdirs();
}
var messagesOfName = entry.getValue();
for (var message : messagesOfName) {
var commandId = message.getTargetAggregateIdentifier();
var commandMetaData = message.getCommandMetaData();
var date = this.getDispatchedAtDate(commandName, commandId, commandMetaData);
if (date.isEmpty()) {
continue;
}
var fileName = this.createFileName(commandId, date.get());
var filePath = directoryPath + File.separator + fileName;
// Check if the file already exists and add a number to the filename if it does
int count = 1;
while (new File(filePath).exists()) {
fileName = this.createFileName(commandId + "_" + count, date.get());
filePath = directoryPath + File.separator + fileName;
count++;
}
try (var writer = new FileWriter(filePath)) {
writer.write(this.objectMapper.writeValueAsString(message.getCommandPayload()));
}
}
}
this.eventGateway.publish(new CommandFixturesCommitted());
}
@NotNull
private String createFileName(String commandId, Date date) {
var dateString = this.fileDateFormat.format(date);
return dateString + "." + commandId + ".profile.custom.json";
}
private Optional<Date> getDispatchedAtDate(
String commandName,
String commandId,
Map<String, Object> commandMetaData
) {
var dispatchedAtMetadataKey = CommandDispatchedAtInterceptor.DISPATCHED_AT_METADATA_KEY;
var dispatchedAt = commandMetaData.get(dispatchedAtMetadataKey);
if (dispatchedAt instanceof String dispatchedAtString) {
try {
var timestamp = Timestamp.valueOf(dispatchedAtString);
return Optional.of(new Date(timestamp.getTime()));
} catch (IllegalArgumentException e) {
this.logWarning(
commandName,
commandId,
"it could parse metaData value at key: " + dispatchedAtMetadataKey,
e
);
}
}
this.logWarning(
commandName,
commandId,
"it does not contain " + dispatchedAtMetadataKey + " field in metaData."
);
return Optional.empty();
}
private void logWarning(
String commandName,
String commandId,
String becauseMessage
) {
var message = this.formatLogMessage(commandName, commandId, becauseMessage);
this.logger.warn(message);
}
private void logWarning(
String commandName,
String commandId,
String becauseMessage,
Exception cause
) {
var message = this.formatLogMessage(commandName, commandId, becauseMessage);
this.logger.warn(message, cause);
}
private String formatLogMessage(String commandName, String commandId, String becauseMessage) {
return String.format(
"Persisted Command Message of type: '%s' with id: '%s' could not committed, because %s",
commandName,
commandId,
becauseMessage
);
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/commandpersisting/CommitCommandFixturesLineRunner.java | package ai.stapi.axonsystemplugin.commandpersisting;
import ai.stapi.axonsystem.commandpersisting.CommitCommandFixtures;
import java.util.Arrays;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ApplicationContext;
public class CommitCommandFixturesLineRunner implements CommandLineRunner {
private final CommandGateway commandGateway;
private final ApplicationContext applicationContext;
public CommitCommandFixturesLineRunner(
CommandGateway commandGateway,
ApplicationContext applicationContext
) {
this.commandGateway = commandGateway;
this.applicationContext = applicationContext;
}
@Override
public void run(String... args) {
var outputDirectoryPath = getOutputDirectoryPath(args);
this.commandGateway.sendAndWait(new CommitCommandFixtures(outputDirectoryPath));
var exitCode = SpringApplication.exit(this.applicationContext, () -> 0);
System.exit(exitCode);
}
public static String getOutputDirectoryPath(String... args) {
if (args.length == 0) {
throw new RuntimeException("Please specify path where to commit persisted commands as command line argument.");
}
var path = Arrays.stream(args)
.filter(arg -> arg.startsWith("_outputPath:"))
.map(arg -> arg.replace("_outputPath:", ""))
.findFirst();
return path.orElse(args[0]);
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/commandpersisting/WipePersistedCommandAfterCommitPolicy.java | package ai.stapi.axonsystemplugin.commandpersisting;
import ai.stapi.axonsystem.commandpersisting.CommandFixturesCommitted;
import ai.stapi.axonsystem.commandpersisting.CommandMessageStore;
import org.axonframework.eventhandling.EventHandler;
public class WipePersistedCommandAfterCommitPolicy {
private final CommandMessageStore commandMessageStore;
public WipePersistedCommandAfterCommitPolicy(CommandMessageStore commandMessageStore) {
this.commandMessageStore = commandMessageStore;
}
@EventHandler
public void on(CommandFixturesCommitted event) {
this.commandMessageStore.wipeAll();
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/configuration/AxonSystemPluginConfiguration.java | package ai.stapi.axonsystemplugin.configuration;
import ai.stapi.axonsystem.commandpersisting.CommandMessageStore;
import ai.stapi.axonsystemplugin.DefaultGraphProjection;
import ai.stapi.axonsystemplugin.commandpersisting.CommitCommandFixturesHandler;
import ai.stapi.axonsystemplugin.commandpersisting.CommitCommandFixturesLineRunner;
import ai.stapi.axonsystemplugin.commandpersisting.WipePersistedCommandAfterCommitPolicy;
import ai.stapi.axonsystemplugin.fixtures.FixtureCommandsApplier;
import ai.stapi.axonsystemplugin.fixtures.GenerateFixturesCommandLineRunner;
import ai.stapi.axonsystemplugin.structuredefinition.configure.ConfigureStructureDefinitionHandler;
import ai.stapi.graph.EdgeRepository;
import ai.stapi.graph.NodeRepository;
import ai.stapi.graphoperations.synchronization.GraphSynchronizer;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.eventhandling.gateway.EventGateway;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Profile;
@AutoConfiguration
@ComponentScan("ai.stapi.axonsystemplugin.fixtures")
@ComponentScan("ai.stapi.axonsystemplugin.structuredefinition")
public class AxonSystemPluginConfiguration {
@Bean
public DefaultGraphProjection defaultGraphProjection(
NodeRepository nodeRepository,
EdgeRepository edgeRepository,
GraphSynchronizer graphSynchronizer
) {
return new DefaultGraphProjection(nodeRepository, edgeRepository, graphSynchronizer);
}
@Bean
public ConfigureStructureDefinitionHandler configureStructureDefinitionHandler(
EventGateway eventGateway,
StructureSchemaProvider structureSchemaProvider,
StructureSchemaFinder structureSchemaFinder
) {
return new ConfigureStructureDefinitionHandler(
eventGateway,
structureSchemaProvider,
structureSchemaFinder
);
}
@Bean
public FixtureCommandsApplier fixtureCommandsApplier(CommandGateway commandGateway) {
return new FixtureCommandsApplier(commandGateway);
}
@Bean
public CommitCommandFixturesHandler commitCommandFixturesHandler(
CommandMessageStore commandMessageStore,
EventGateway eventGateway,
ObjectMapper objectMapper
) {
return new CommitCommandFixturesHandler(
commandMessageStore,
eventGateway,
objectMapper
);
}
@Bean
public WipePersistedCommandAfterCommitPolicy wipePersistedCommandAfterCommitPolicy(
CommandMessageStore commandMessageStore
) {
return new WipePersistedCommandAfterCommitPolicy(commandMessageStore);
}
@Bean
@Profile("generate-fixtures")
public GenerateFixturesCommandLineRunner generateFixturesCommandLineRunner(
CommandGateway commandGateway,
DefaultGraphProjection graphProjection,
ApplicationContext applicationContext
) {
return new GenerateFixturesCommandLineRunner(
commandGateway,
graphProjection,
applicationContext
);
}
@Bean
@Profile("commit-command-fixtures")
public CommitCommandFixturesLineRunner commitCommandFixturesLineRunner(
CommandGateway commandGateway,
ApplicationContext applicationContext
) {
return new CommitCommandFixturesLineRunner(commandGateway, applicationContext);
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/configuration/DevAxonSystemPluginConfiguration.java | package ai.stapi.axonsystemplugin.configuration;
import ai.stapi.axonsystemplugin.aggregatedefinition.CreateAggregateDefinitionPolicy;
import ai.stapi.axonsystemplugin.aggregatedefinition.createCRUDCommandHandlers.CreateAddItemCommandHandlerPolicy;
import ai.stapi.axonsystemplugin.aggregatedefinition.createCRUDCommandHandlers.CreateCreationalCommandHandlerPolicy;
import ai.stapi.axonsystemplugin.aggregatedefinition.createCRUDCommandHandlers.CreateUpdateCommandHandlerPolicy;
import ai.stapi.axonsystemplugin.structuredefinition.configure.ConfigureImportedStructureDefinitionPolicy;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoaderProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.ResourceAggregateDefinitionMapper;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.CreatedOperationEventFactoriesMapper;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.ItemAddedOperationEventFactoriesMapper;
import ai.stapi.graphsystem.aggregatedefinition.model.eventFactory.UpdatedOperationEventFactoriesMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.AddItemOnResourceOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.CreationalResourceOperationMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.UpdateResourceOperationMapper;
import ai.stapi.schema.structureSchemaMapper.StructureDefinitionToSSMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
@AutoConfiguration
@Profile("dev")
public class DevAxonSystemPluginConfiguration {
@Bean
public ConfigureImportedStructureDefinitionPolicy configureImportedStructureDefinitionPolicy(
InMemoryGraphLoaderProvider inMemoryGraphLoaderProvider,
CommandGateway commandGateway
) {
return new ConfigureImportedStructureDefinitionPolicy(
commandGateway,
inMemoryGraphLoaderProvider
);
}
@Bean
public CreateAggregateDefinitionPolicy createAggregateDefinitionPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ResourceAggregateDefinitionMapper aggregateDefinitionMapper,
ObjectMapper objectMapper
) {
return new CreateAggregateDefinitionPolicy(
commandGateway,
structureSchemaFinder,
aggregateDefinitionMapper,
objectMapper
);
}
@Bean
public CreateCreationalCommandHandlerPolicy createCreationalCommandHandlerPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper,
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
CreationalResourceOperationMapper creationalResourceOperationMapper,
CreatedOperationEventFactoriesMapper createdOperationEventDefinitionMapper
) {
return new CreateCreationalCommandHandlerPolicy(
commandGateway,
structureSchemaFinder,
objectMapper,
structureDefinitionToSSMapper,
creationalResourceOperationMapper,
createdOperationEventDefinitionMapper
);
}
@Bean
public CreateAddItemCommandHandlerPolicy createAddItemCommandHandlerPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper,
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
AddItemOnResourceOperationsMapper addItemOnResourceOperationsMapper,
ItemAddedOperationEventFactoriesMapper itemAddedOperationEventMessageMapper
) {
return new CreateAddItemCommandHandlerPolicy(
commandGateway,
structureSchemaFinder,
objectMapper,
structureDefinitionToSSMapper,
addItemOnResourceOperationsMapper,
itemAddedOperationEventMessageMapper
);
}
@Bean
public CreateUpdateCommandHandlerPolicy createUpdateCommandHandlerPolicy(
CommandGateway commandGateway,
StructureSchemaFinder structureSchemaFinder,
ObjectMapper objectMapper,
StructureDefinitionToSSMapper structureDefinitionToSSMapper,
UpdateResourceOperationMapper updateResourceOperationMapper,
UpdatedOperationEventFactoriesMapper updatedOperationEventFactoriesMapper
) {
return new CreateUpdateCommandHandlerPolicy(
commandGateway,
structureSchemaFinder,
objectMapper,
structureDefinitionToSSMapper,
updateResourceOperationMapper,
updatedOperationEventFactoriesMapper
);
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/fixtures/FixtureCommandsApplier.java | package ai.stapi.axonsystemplugin.fixtures;
import ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator.FixtureCommandsGeneratorResult;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class FixtureCommandsApplier {
private final CommandGateway commandGateway;
private final Logger logger;
public FixtureCommandsApplier(
CommandGateway commandGateway
) {
this.commandGateway = commandGateway;
this.logger = LoggerFactory.getLogger(FixtureCommandsApplier.class);
}
public void apply(FixtureCommandsGeneratorResult result) {
result.getCommandDefinitions().forEach(definition -> {
this.logger.info(
"Applying fixture command of type: " + definition.getName() +
"\nLocated in generator: " + result.getGeneratorClassName()
);
this.commandGateway.sendAndWait(definition.getCommand());
});
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/fixtures/FixtureGenerated.java | package ai.stapi.axonsystemplugin.fixtures;
import ai.stapi.graphsystem.messaging.event.Event;
import java.util.Set;
public class FixtureGenerated implements Event {
private String generatorClassName;
private Set<String> fixtureFileNames;
private boolean isOneTimeGenerator;
private FixtureGenerated() {
}
public FixtureGenerated(
String generatorClassName,
Set<String> fixtureFileNames,
boolean isOneTimeGenerator
) {
this.generatorClassName = generatorClassName;
this.fixtureFileNames = fixtureFileNames;
this.isOneTimeGenerator = isOneTimeGenerator;
}
public String getGeneratorClassName() {
return generatorClassName;
}
public Set<String> getFixtureFileNames() {
return fixtureFileNames;
}
public boolean isOneTimeGenerator() {
return isOneTimeGenerator;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/fixtures/Fixtures.java | package ai.stapi.axonsystemplugin.fixtures;
import ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator.FixtureCommandsGeneratorResult;
import ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator.GenericFixtureCommandsGenerator;
import ai.stapi.schema.structureSchemaMapper.UnresolvableType;
import ai.stapi.schema.structureSchemaProvider.DefaultStructureSchemaProvider;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import org.axonframework.commandhandling.CommandHandler;
import org.axonframework.eventsourcing.EventSourcingHandler;
import org.axonframework.modelling.command.AggregateCreationPolicy;
import org.axonframework.modelling.command.AggregateIdentifier;
import org.axonframework.modelling.command.AggregateLifecycle;
import org.axonframework.modelling.command.AggregateVersion;
import org.axonframework.modelling.command.CreationPolicy;
import org.axonframework.spring.stereotype.Aggregate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@Aggregate
public class Fixtures {
public static final String TARGET_AGGREGATE_IDENTIFIER = "Fixtures";
@AggregateIdentifier
private final String targetAggregateIdentifier = TARGET_AGGREGATE_IDENTIFIER;
private final List<String> usedGenerators = new ArrayList<>();
private final Set<String> processedFileNames = new HashSet<>();
private final Logger logger = LoggerFactory.getLogger(Fixtures.class);
@AggregateVersion
private long version;
public Fixtures() {
}
@CommandHandler
@CreationPolicy(AggregateCreationPolicy.CREATE_IF_MISSING)
public void handle(
GenerateFixtures command,
@Autowired GenericFixtureCommandsGenerator generator,
@Autowired FixtureCommandsApplier applier,
@Autowired DefaultStructureSchemaProvider provider
) {
this.generateStructuresWithPriority(
command,
generator,
applier,
logger,
command.getMinPriority(),
command.getMaxPriority()
);
if (!provider.getCurrentFailedTypes().isEmpty()) {
var missingDependencies = provider.getCurrentFailedTypes().stream()
.map(UnresolvableType::missingDependencies)
.flatMap(List::stream)
.toList()
.stream()
.distinct()
.toList();
var failedTypes = provider.getCurrentFailedTypes().stream()
.map(UnresolvableType::structureDefinitionData)
.map(StructureDefinitionData::getId)
.distinct()
.toList();
this.logger.warn(
"Missing dependencies in DefaultStructureSchemaProvider: [" + System.lineSeparator()
+ StringUtils.join(missingDependencies, "," + System.lineSeparator())
+ System.lineSeparator() + "]"
);
this.logger.warn(
"Remaining unresolved types in DefaultStructureSchemaProvider: [" + System.lineSeparator()
+ StringUtils.join(failedTypes, "," + System.lineSeparator())
+ System.lineSeparator() + "]"
);
}
}
private void generateStructuresWithPriority(
GenerateFixtures command,
GenericFixtureCommandsGenerator generator,
FixtureCommandsApplier applier,
Logger logger,
float minPriority,
float maxPriority
) {
var results = generator.generate(
command.getFixtureTags(),
this.usedGenerators,
this.processedFileNames,
minPriority,
maxPriority
);
var resultsWhichHaventBeenExecuted = results.filter(
result -> !this.usedGenerators.contains(result.getGeneratorClassName())
&& result.getCommandDefinitions().size() > 0
).toList();
var count = resultsWhichHaventBeenExecuted.stream().count();
logger.info(String.format("Found %s fixture generators which havent been executed.", count));
resultsWhichHaventBeenExecuted.forEach(result -> this.processResult(result, applier));
}
@EventSourcingHandler
public void on(FixtureGenerated event) {
if (event.isOneTimeGenerator()) {
this.usedGenerators.add(event.getGeneratorClassName());
}
this.processedFileNames.addAll(event.getFixtureFileNames());
}
private void processResult(
FixtureCommandsGeneratorResult result,
FixtureCommandsApplier fixtureApplier
) {
fixtureApplier.apply(result);
var event = new FixtureGenerated(
result.getGeneratorClassName(),
result.getProcessedFiles(),
result.isOneTimeGenerator()
);
AggregateLifecycle.apply(event);
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/fixtures/GenerateFixtures.java | package ai.stapi.axonsystemplugin.fixtures;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.identity.UniqueIdentifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class GenerateFixtures extends AbstractCommand<UniqueIdentifier> {
public static final String SERIALIZATION_TYPE = "GenerateFixtures";
public static final String TARGET_IDENTIFIER = Fixtures.TARGET_AGGREGATE_IDENTIFIER;
private List<String> fixtureTags;
private float minPriority = 0;
private float maxPriority = 1000000;
private GenerateFixtures() {
super(new UniqueIdentifier(TARGET_IDENTIFIER), SERIALIZATION_TYPE);
}
public GenerateFixtures(String... fixtureTags) {
super(new UniqueIdentifier(TARGET_IDENTIFIER), SERIALIZATION_TYPE);
this.fixtureTags = Arrays.stream(fixtureTags).collect(Collectors.toList());
}
public GenerateFixtures(
List<String> fixtureTags,
float minPriority,
float maxPriority
) {
super(new UniqueIdentifier(TARGET_IDENTIFIER), SERIALIZATION_TYPE);
this.fixtureTags = new ArrayList<>(fixtureTags);
this.minPriority = minPriority;
this.maxPriority = maxPriority;
}
public List<String> getFixtureTags() {
return fixtureTags;
}
public float getMinPriority() {
return minPriority;
}
public float getMaxPriority() {
return maxPriority;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/fixtures/GenerateFixturesCommandLineRunner.java | package ai.stapi.axonsystemplugin.fixtures;
import ai.stapi.axonsystemplugin.DefaultGraphProjection;
import java.time.Duration;
import java.util.List;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ApplicationContext;
public class GenerateFixturesCommandLineRunner implements CommandLineRunner {
private final CommandGateway commandGateway;
private final DefaultGraphProjection graphProjection;
private final ApplicationContext applicationContext;
private final Logger logger;
public GenerateFixturesCommandLineRunner(
CommandGateway commandGateway,
DefaultGraphProjection graphProjection,
ApplicationContext applicationContext
) {
this.commandGateway = commandGateway;
this.graphProjection = graphProjection;
this.applicationContext = applicationContext;
this.logger = LoggerFactory.getLogger(GenerateFixturesCommandLineRunner.class);
}
@Override
public void run(String... args) throws Exception {
this.logger.info("Going to synchronize structure fixtures");
generate(
Float.MIN_VALUE,
Float.MAX_VALUE,
args
);
var exitCode = SpringApplication.exit(this.applicationContext, () -> 0);
System.exit(exitCode);
}
private void generate(float minPriority, float maxPriority, String[] args) {
var command = new GenerateFixtures(
List.of(args),
minPriority,
maxPriority
);
this.logger.info("Sending generate fixtures command");
this.commandGateway.send(command);
var lastEventTime = this.graphProjection.getLastEventTime();
while (true) {
try {
Thread.sleep(15000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
var newTime = this.graphProjection.getLastEventTime();
if (Duration.between(lastEventTime, newTime).getSeconds() == 0) {
return;
}
lastEventTime = newTime;
}
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition/StructureDefinition.java | package ai.stapi.axonsystemplugin.structuredefinition;
import ai.stapi.axonsystem.graphaggregate.AggregateWithDynamicGraph;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.ImportStructureDefinition;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.StructureDefinitionImported;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import ai.stapi.schema.structuredefinition.StructureDefinitionNormalizer;
import org.axonframework.commandhandling.CommandHandler;
import org.axonframework.eventsourcing.EventSourcingHandler;
import org.axonframework.modelling.command.AggregateCreationPolicy;
import org.axonframework.modelling.command.CreationPolicy;
import org.axonframework.spring.stereotype.Aggregate;
import org.springframework.beans.factory.annotation.Autowired;
@Aggregate
public class StructureDefinition extends AggregateWithDynamicGraph<StructureDefinitionId> {
@CommandHandler
@CreationPolicy(AggregateCreationPolicy.CREATE_IF_MISSING)
public void handle(
ImportStructureDefinition command,
@Autowired DynamicCommandProcessor commandProcessor
) {
this.commandProcessor = commandProcessor;
this.processCommandDynamically(
new ImportStructureDefinition(
command.getTargetIdentifier(),
StructureDefinitionNormalizer.normalize(command.getStructureDefinitionSource())
),
MissingFieldResolvingStrategy.LENIENT
);
}
@EventSourcingHandler
public void on(StructureDefinitionImported event) {
this.onAggregateCreated(event);
}
} |
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition/configure/ConfigureElementsToStructureDefinition.java | package ai.stapi.axonsystemplugin.structuredefinition.configure;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structuredefinition.ElementDefinition;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.List;
public class ConfigureElementsToStructureDefinition extends AbstractCommand<UniqueIdentifier> {
public static final String SERIALIZATION_TYPE = "ConfigureElementsToStructureDefinition";
public static final String TARGET_AGGREGATE_IDENTIFIER = "ConfigureStructureDefinitionHandler";
private StructureDefinitionId structureDefinitionId;
private List<ElementDefinition> elementDefinitions;
private ConfigureElementsToStructureDefinition() {
}
public ConfigureElementsToStructureDefinition(
StructureDefinitionId structureDefinitionId,
List<ElementDefinition> elementDefinitions
) {
super(new UniqueIdentifier(TARGET_AGGREGATE_IDENTIFIER), SERIALIZATION_TYPE);
this.structureDefinitionId = structureDefinitionId;
this.elementDefinitions = elementDefinitions;
}
public StructureDefinitionId getStructureDefinitionId() {
return structureDefinitionId;
}
public List<ElementDefinition> getElementDefinitions() {
return elementDefinitions;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition/configure/ConfigureImportedStructureDefinitionPolicy.java | package ai.stapi.axonsystemplugin.structuredefinition.configure;
import ai.stapi.axonsystem.dynamic.event.DynamicEventHandler;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.graphLoader.GraphLoaderReturnType;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoaderProvider;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.StructureDefinitionImported;
import ai.stapi.graphsystem.structuredefinition.loader.DatabaseStructureDefinitionLoader;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structuredefinition.ElementDefinition;
import ai.stapi.schema.structuredefinition.ElementDefinitionType;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.List;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.eventhandling.EventHandler;
import org.jetbrains.annotations.Nullable;
public class ConfigureImportedStructureDefinitionPolicy {
private final CommandGateway commandGateway;
private final InMemoryGraphLoaderProvider inMemoryGraphLoaderProvider;
public ConfigureImportedStructureDefinitionPolicy(
CommandGateway commandGateway,
InMemoryGraphLoaderProvider inMemoryGraphLoaderProvider
) {
this.commandGateway = commandGateway;
this.inMemoryGraphLoaderProvider = inMemoryGraphLoaderProvider;
}
@EventHandler
public void on(StructureDefinitionImported event) {
this.configureStructureDefinition(event);
}
@DynamicEventHandler(messageName = "StructureDefinitionCreated")
public void on(DynamicGraphUpdatedEvent event) {
this.configureStructureDefinition(event);
}
private void configureStructureDefinition(
AggregateGraphUpdatedEvent<? extends UniqueIdentifier> event
) {
var loader = this.inMemoryGraphLoaderProvider.provide(event.getSynchronizedGraph());
var output = loader.get(
event.getIdentity(),
DatabaseStructureDefinitionLoader.STRUCTURE_DEFINITION_GRAPH_DESCRIPTION,
StructureDefinitionData.class,
GraphLoaderReturnType.OBJECT
);
this.commandGateway.send(
new ConfigureStructureDefinition(output.getData())
);
}
@DynamicEventHandler(messageName = "ElementOnStructureDefinitionDifferentialAdded")
public void onElementAdded(DynamicGraphUpdatedEvent event) {
var structureId = event.getIdentity().getId();
var graph = event.getSynchronizedGraph().traversable();
var differentials = graph.loadAllNodes(
"StructureDefinitionDifferential"
);
if (differentials.size() != 1) {
throw new RuntimeException("This should never happen.");
}
var differential = differentials.get(0);
var elements = differential.getEdges("element")
.stream()
.map(TraversableEdge::getNodeTo)
.map(node -> new ElementDefinition(
this.getAttributeOrNull(node, "path", String.class),
node.getEdges("type").stream()
.map(TraversableEdge::getNodeTo)
.map(typeNode -> new ElementDefinitionType(
this.getAttributeOrNull(typeNode, "code", String.class),
(List<String>) this.getAttributeOrNull(typeNode, "targetProfile", List.class)
))
.toList(),
this.getAttributeOrNull(node, "min", Integer.class),
this.getAttributeOrNull(node, "max", String.class),
this.getAttributeOrNull(node, "shortDescription", String.class),
this.getAttributeOrNull(node, "definition", String.class),
this.getAttributeOrNull(node, "comment", String.class)
))
.toList();
this.commandGateway.send(
new ConfigureElementsToStructureDefinition(
new StructureDefinitionId(structureId),
elements
)
);
}
@Nullable
private <T> T getAttributeOrNull(
TraversableNode node,
String attributeName,
Class<T> clazz
) {
if (!node.hasAttribute(attributeName)) {
return null;
}
return (T) node.getAttribute(attributeName).getValue();
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition/configure/ConfigureStructureDefinition.java | package ai.stapi.axonsystemplugin.structuredefinition.configure;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
public class ConfigureStructureDefinition extends AbstractCommand<UniqueIdentifier> {
public static final String SERIALIZATION_TYPE = "ConfigureStructureDefinition";
public static final String TARGET_AGGREGATE_IDENTIFIER = "ConfigureStructureDefinitionHandler";
private StructureDefinitionData structureDefinitionData;
private ConfigureStructureDefinition() {
}
public ConfigureStructureDefinition(StructureDefinitionData structureDefinitionData) {
super(new UniqueIdentifier(TARGET_AGGREGATE_IDENTIFIER), SERIALIZATION_TYPE);
this.structureDefinitionData = structureDefinitionData;
}
public StructureDefinitionData getStructureDefinitionData() {
return structureDefinitionData;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition/configure/ConfigureStructureDefinitionHandler.java | package ai.stapi.axonsystemplugin.structuredefinition.configure;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import ai.stapi.schema.structuredefinition.ElementDefinition;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.stream.Collectors;
import org.axonframework.commandhandling.CommandHandler;
import org.axonframework.eventhandling.gateway.EventGateway;
public class ConfigureStructureDefinitionHandler {
private final EventGateway eventGateway;
private final StructureSchemaProvider structureSchemaProvider;
private final StructureSchemaFinder structureSchemaFinder;
public ConfigureStructureDefinitionHandler(
EventGateway eventGateway,
StructureSchemaProvider structureSchemaProvider,
StructureSchemaFinder structureSchemaFinder
) {
this.eventGateway = eventGateway;
this.structureSchemaProvider = structureSchemaProvider;
this.structureSchemaFinder = structureSchemaFinder;
}
@CommandHandler
public void handle(ConfigureStructureDefinition command) {
var structureDefinitionDTO = command.getStructureDefinitionData();
this.structureSchemaProvider.add(structureDefinitionDTO);
this.eventGateway.publish(
new StructureDefinitionConfigured(
new StructureDefinitionId(structureDefinitionDTO.getId()),
structureDefinitionDTO.getKind()
)
);
}
@CommandHandler
public void handle(ConfigureElementsToStructureDefinition command) {
var structureType = command.getStructureDefinitionId().getId();
var existingStructure = this.structureSchemaFinder.getStructureType(
structureType
);
var parentType = existingStructure.getParent();
var elementDefinitions = command.getElementDefinitions();
var newStructure = new StructureDefinitionData(
existingStructure.getDefinitionType(),
null,
null,
null,
existingStructure.getKind(),
existingStructure.isAbstract(),
existingStructure.getDefinitionType(),
null,
parentType == null ? null : new UniqueIdentifier(parentType),
elementDefinitions
);
this.structureSchemaProvider.add(newStructure);
this.eventGateway.publish(
new ElementsToStructureDefinitionConfigured(
new StructureDefinitionId(structureType),
existingStructure.getKind(),
elementDefinitions.stream().map(ElementDefinition::getPath).collect(Collectors.toList())
)
);
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition/configure/ElementsToStructureDefinitionConfigured.java | package ai.stapi.axonsystemplugin.structuredefinition.configure;
import ai.stapi.graphsystem.messaging.event.Event;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.List;
public class ElementsToStructureDefinitionConfigured implements Event {
private StructureDefinitionId structureDefinitionId;
private String kind;
private List<String> elementPaths;
private ElementsToStructureDefinitionConfigured() {
}
public ElementsToStructureDefinitionConfigured(
StructureDefinitionId structureDefinitionId,
String kind,
List<String> elementPaths
) {
this.structureDefinitionId = structureDefinitionId;
this.kind = kind;
this.elementPaths = elementPaths;
}
public StructureDefinitionId getStructureDefinitionId() {
return structureDefinitionId;
}
public String getKind() {
return kind;
}
public List<String> getElementPaths() {
return elementPaths;
}
}
|
0 | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition | java-sources/ai/stapi/axon-system-plugin/0.2.3/ai/stapi/axonsystemplugin/structuredefinition/configure/StructureDefinitionConfigured.java | package ai.stapi.axonsystemplugin.structuredefinition.configure;
import ai.stapi.graphsystem.messaging.event.Event;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
public class StructureDefinitionConfigured implements Event {
private StructureDefinitionId structureDefinitionId;
private String kind;
private StructureDefinitionConfigured() {
}
public StructureDefinitionConfigured(
StructureDefinitionId structureDefinitionId,
String kind
) {
this.structureDefinitionId = structureDefinitionId;
this.kind = kind;
}
public StructureDefinitionId getStructureDefinitionId() {
return structureDefinitionId;
}
public String getKind() {
return kind;
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/acceptance/AcceptanceTestCase.java | package ai.stapi.test.acceptance;
import ai.stapi.test.base.AbstractAxonTestCase;
import org.junit.jupiter.api.Tag;
import org.springframework.test.context.ContextConfiguration;
@Tag("acceptance")
@ContextConfiguration(classes = {AcceptanceTestCaseConfig.class})
public abstract class AcceptanceTestCase extends AbstractAxonTestCase {
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/acceptance/AcceptanceTestCaseConfig.java | package ai.stapi.test.acceptance;
import ai.stapi.graphsystem.structuredefinition.loader.DatabaseStructureDefinitionLoader;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import org.axonframework.config.ConfigurerModule;
import org.axonframework.eventhandling.PropagatingErrorHandler;
import org.axonframework.eventhandling.tokenstore.TokenStore;
import org.axonframework.eventhandling.tokenstore.inmemory.InMemoryTokenStore;
import org.axonframework.eventsourcing.eventstore.EmbeddedEventStore;
import org.axonframework.eventsourcing.eventstore.EventStore;
import org.axonframework.eventsourcing.eventstore.inmemory.InMemoryEventStorageEngine;
import org.axonframework.queryhandling.QueryBus;
import org.axonframework.queryhandling.SimpleQueryBus;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
public class AcceptanceTestCaseConfig {
@Bean
@Primary
public static StructureDefinitionLoader structureDefinitionLoader(
DatabaseStructureDefinitionLoader dbLoader) {
return dbLoader;
}
@Bean
public static EventStore createEventStore() {
return new EmbeddedEventStore.Builder().storageEngine(new InMemoryEventStorageEngine()).build();
}
@Bean
@Primary
public static TokenStore createTokenStore() {
return new InMemoryTokenStore();
}
@Bean
@Primary
public static QueryBus createQueryBus() {
return new SimpleQueryBus.Builder().build();
}
@Bean
public ConfigurerModule processorDefaultConfigurerModule() {
return configurer -> configurer.eventProcessing(
eventProcessingConfigurer -> eventProcessingConfigurer
.registerDefaultListenerInvocationErrorHandler(
configuration -> PropagatingErrorHandler.INSTANCE)
.usingSubscribingEventProcessors()
);
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/base/AbstractAxonTestCase.java | package ai.stapi.test.base;
import static org.junit.jupiter.api.Assertions.assertTrue;
import ai.stapi.axonsystem.dynamic.aggregate.DynamicAggregateConfigurer;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import ai.stapi.graphsystem.messaging.event.Event;
import ai.stapi.graphsystem.messaging.event.GraphUpdatedEvent;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.objectRenderer.infrastructure.objectToJsonStringRenderer.ObjectToJSonStringOptions;
import ai.stapi.test.domain.TestInMemoryEventStorageEngine;
import ai.stapi.test.schemaintegration.AbstractSchemaIntegrationTestCase;
import ai.stapi.utils.LineFormatter;
import ai.stapi.utils.Retryable;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import org.axonframework.eventhandling.DomainEventMessage;
import org.axonframework.eventhandling.TrackedEventMessage;
import org.axonframework.eventhandling.TrackingEventStream;
import org.axonframework.eventhandling.tokenstore.TokenStore;
import org.axonframework.eventsourcing.eventstore.EmbeddedEventStore;
import org.axonframework.eventsourcing.eventstore.EventStorageEngine;
import org.axonframework.messaging.Message;
import org.axonframework.messaging.MetaData;
import org.axonframework.serialization.Serializer;
import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class AbstractAxonTestCase extends AbstractSchemaIntegrationTestCase {
@Autowired
@Qualifier("messageSerializer")
protected Serializer serializer;
@Autowired
private TokenStore tokenstore;
@Autowired
private EmbeddedEventStore eventStore;
@Autowired
private EventStorageEngine eventStorageEngine;
@Autowired
private DynamicAggregateConfigurer dynamicAggregateConfigurer;
private Instant testStartedAt;
@BeforeEach
@Order(1)
protected void configureAggregates() {
this.dynamicAggregateConfigurer.configureNewAggregates();
}
@BeforeEach
protected void initStartedAt() {
this.testStartedAt = Instant.now();
if (this.eventStorageEngine instanceof TestInMemoryEventStorageEngine testStorage) {
testStorage.reset();
}
}
protected void thenExpectedEventTypesSaved(Class<?>... expectedEventTypes) {
this.thenExpectedEventTypesSaved(Arrays.stream(expectedEventTypes).toList());
}
protected void thenExpectedEventTypesSaved(List<Class<?>> expectedEventTypes) {
int retries = 20;
int expectedEventCount = expectedEventTypes.size();
List<Class<?>> actualEventTypes = Retryable.retry(retries, 200, () -> {
List<Class<?>> eventTypes = this.getActualEventTypes(this.getActualEventStream());
return eventTypes;
}, expectedEventCount);
//
Assertions.assertEquals(
expectedEventTypes.size(),
actualEventTypes.size(),
this.getErrorMessage(expectedEventTypes, actualEventTypes)
);
assertEventTypeListsAreSame(expectedEventTypes, actualEventTypes);
this.thenSavedEventsCanBeSerialized();
}
protected void thenExpectedDynamicEventsSaved(String... expectedEventNames) {
this.thenExpectedDynamicEventsSaved(Arrays.stream(expectedEventNames).toList());
}
protected void thenExpectedDynamicEventsSaved(List<String> expectedEventNames) {
var actualEventsOfType = Retryable.retry(
100, 100, () -> {
var actualEventStream = this.getActualEventStream();
var eventsOfType = this.getActualEvents(actualEventStream).stream()
.filter(o -> o instanceof DynamicGraphUpdatedEvent)
.map(o -> (DynamicGraphUpdatedEvent) o)
.collect(Collectors.toList());
return eventsOfType;
},
expectedEventNames.size()
);
Assertions.assertEquals(
expectedEventNames.size(),
actualEventsOfType.size(),
this.getDynamicEventsErrorMessage(expectedEventNames, actualEventsOfType)
);
this.assertDynamicEventsHaveCorrectNames(expectedEventNames, actualEventsOfType);
this.thenSavedEventsCanBeSerialized();
}
protected <T extends Event> T getLastEventOfType(Class<T> eventType) {
return this.getLastEventOfType(eventType, 1);
}
protected DynamicGraphUpdatedEvent getLastDynamicEventOfName(String eventName) {
return this.getLastDynamicEventOfName(eventName, 1);
}
protected DynamicGraphUpdatedEvent getLastDynamicEventOfName(
String eventName,
int expectedNumberOfEvents
) {
var actualEventsOfType = Retryable.retry(
100, 100, () -> {
var actualEventStream = this.getActualEventStream();
var eventsOfType = this.getActualEvents(actualEventStream).stream()
.filter(o -> o instanceof DynamicGraphUpdatedEvent)
.map(o -> (DynamicGraphUpdatedEvent) o)
.filter(dynamicGraphUpdatedEvent -> dynamicGraphUpdatedEvent.getEventName()
.equals(eventName))
.collect(Collectors.toList());
return eventsOfType;
},
expectedNumberOfEvents
);
Assertions.assertNotNull(actualEventsOfType, "No events found.");
Assertions.assertEquals(
expectedNumberOfEvents,
actualEventsOfType.size(),
"Not enough events found."
);
return actualEventsOfType.get(actualEventsOfType.size() - 1);
}
protected <T extends Event> T getLastEventOfType(Class<T> eventType, int expectedNumberOfEvents) {
List<Object> actualEventsOfType = Retryable.retry(100, 100, () -> {
var actualEventStream = this.getActualEventStream();
var eventsOfType = this.getActualEvents(actualEventStream).stream()
.filter(o -> o.getClass().equals(eventType)).collect(Collectors.toList());
return eventsOfType;
}, expectedNumberOfEvents);
Assertions.assertNotNull(actualEventsOfType, "No events found.");
Assertions.assertEquals(expectedNumberOfEvents, actualEventsOfType.size(),
"Not enough events found.");
return (T) actualEventsOfType.get(actualEventsOfType.size() - 1);
}
protected MetaData getMetaDataForLastEventOfType(Class<? extends Event> eventType) {
var metaData = this.getActualEventStream().asStream()
.filter(eventMessage -> eventMessage.getPayloadType().equals(eventType))
.map(Message::getMetaData)
.toList();
Assertions.assertTrue(metaData.size() > 0, "No such events found.");
return metaData.get(metaData.size() - 1);
}
protected <T extends Event> Optional<T> getLastEventOfTypeOptionally(Class<T> eventType) {
var actualEventStream = this.getActualEventStream();
return this.getActualEvents(actualEventStream).stream()
.filter(o -> o.getClass().equals(eventType))
.map(event -> (T) event)
.findAny();
}
protected void thenLastEventElementsForRemovalApproved() {
var actualEventStream = this.getActualEventStream();
var actualEvents = this.getActualEvents(actualEventStream);
var uncheckedActualEvent = actualEvents.get(actualEvents.size() - 1);
Assertions.assertTrue(uncheckedActualEvent instanceof GraphUpdatedEvent);
var actualEvent = (GraphUpdatedEvent) uncheckedActualEvent;
this.approveElementsForRemoval(actualEvent.getGraphElementsForRemoval());
}
protected void thenLastEventElementsForRemovalApproved(Class<? extends Event> eventType) {
var uncheckedActualEvent = this.getLastEventOfType(eventType);
Assertions.assertTrue(uncheckedActualEvent instanceof GraphUpdatedEvent);
var actualEvent = (GraphUpdatedEvent) uncheckedActualEvent;
this.approveElementsForRemoval(actualEvent.getGraphElementsForRemoval());
}
protected void thenLastEventGraphApproved() {
var actualEventStream = this.getActualEventStream();
var actualEvents = this.getActualEvents(actualEventStream);
var uncheckedActualEvent = actualEvents.get(actualEvents.size() - 1);
Assertions.assertTrue(uncheckedActualEvent instanceof GraphUpdatedEvent);
var actualEvent = (GraphUpdatedEvent) uncheckedActualEvent;
this.thenGraphApproved(actualEvent.getSynchronizedGraph());
}
protected void thenLastEventOfTypeGraphApproved(
Class<? extends Event> eventType
) {
this.thenLastEventOfTypeGraphApproved(eventType, 1);
}
protected void thenLastEventOfTypeGraphApproved(
Class<? extends Event> eventType,
int expectedNumberOfEvents
) {
var uncheckedActualEvent = this.getLastEventOfType(eventType, expectedNumberOfEvents);
Assertions.assertTrue(uncheckedActualEvent instanceof GraphUpdatedEvent);
var actualEvent = (GraphUpdatedEvent) uncheckedActualEvent;
this.thenGraphApproved(actualEvent.getSynchronizedGraph());
}
protected void thenLastDynamicEventOfNameApproved(
String eventName
) {
var actualEvent = this.getLastDynamicEventOfName(eventName);
this.thenGraphApproved(actualEvent.getSynchronizedGraph());
}
protected void thenLastDynamicEventOfNameApproved(
String eventName,
int expectedNumberOfEvents
) {
var actualEvent = this.getLastDynamicEventOfName(
eventName,
expectedNumberOfEvents
);
this.thenGraphApproved(actualEvent.getSynchronizedGraph());
}
protected void thenMergedGraphOfAggregateApproved(UniqueIdentifier aggregateIdentifier) {
this.thenMergedGraphOfAggregateApproved(aggregateIdentifier.getId());
}
protected List<TrackedEventMessage<?>> getAllTrackedMessagesWithPayloadType(
Class<? extends Event> eventType) {
var eventMessages = this.getActualEventMessages(this.getActualEventStream());
return eventMessages.stream()
.filter(message -> message.getPayloadType().equals(eventType))
.toList();
}
protected <T extends Event> TrackedEventMessage<T> getLastEventMessagesOfPayloadType(
Class<T> eventType
) {
var expectedNumberOfMessages = 1;
List<TrackedEventMessage<?>> actualEvents = Retryable.retry(
20,
100,
() -> {
List<TrackedEventMessage<?>> currentActualEvents = this.getActualEventMessages(
this.getActualEventStream()
)
.stream()
.filter(message -> message.getPayloadType().equals(eventType))
.toList();
return currentActualEvents;
},
1
);
Assertions.assertTrue(actualEvents.size() > 0, "No events of that type found.");
return (TrackedEventMessage<T>) actualEvents.get(actualEvents.size() - 1);
}
protected void thenMergedGraphOfAggregateApproved(String aggregateIdentifier) {
var allEventMessages = this.getActualEventMessages(this.getActualEventStream());
var mergedGraph = allEventMessages.stream()
.filter(message -> message instanceof DomainEventMessage<?>)
.map(message -> (DomainEventMessage<?>) message)
.filter(message -> message.getAggregateIdentifier().equals(aggregateIdentifier))
.map(Message::getPayload)
.filter(payload -> payload instanceof GraphUpdatedEvent)
.map(payload -> (GraphUpdatedEvent) payload)
.reduce(
new Graph(),
this::reduceGraphEvent,
Graph::merge
);
this.thenGraphApproved(mergedGraph);
}
private Graph reduceGraphEvent(
Graph reduced,
GraphUpdatedEvent event
) {
return reduced
.removeGraphElements(event.getGraphElementsForRemoval())
.merge(event.getSynchronizedGraph());
}
private void approveElementsForRemoval(List<GraphElementForRemoval> removals) {
this.thenObjectApproved(
removals.stream()
.sorted(Comparator.comparing(GraphElementForRemoval::getGraphElementId))
.collect(Collectors.toList()),
new ObjectToJSonStringOptions(
ObjectToJSonStringOptions.RenderFeature.SORT_FIELDS,
ObjectToJSonStringOptions.RenderFeature.HIDE_IDS
)
);
}
private void thenSavedEventsCanBeSerialized() {
var actualEvents = this.getActualEvents(this.getActualEventStream());
actualEvents.forEach(this::thenEventCanBeSerialized);
}
private void thenEventCanBeSerialized(Object recordedEvent) {
var serializedEvent = this.serializer.serialize(
recordedEvent,
String.class
);
var deserializedObject = this.serializer.deserialize(serializedEvent);
assertTrue(
deserializedObject instanceof Event,
String.format(
"\n%s\ndoes not implement:\n%s.",
deserializedObject.getClass(),
Event.class
)
);
var deserializedEvent = (Event) deserializedObject;
Assertions.assertEquals(recordedEvent.getClass(), deserializedEvent.getClass());
//TODO: Make working equals
}
private void assertEventTypeListsAreSame(
List<Class<?>> expectedEventTypes,
List<Class<?>> actualEventTypes
) {
var actualEventTypesIterator = actualEventTypes.iterator();
expectedEventTypes.forEach(expectedEventType ->
Assertions.assertEquals(
expectedEventType,
actualEventTypesIterator.next(),
this.getErrorMessage(expectedEventTypes, actualEventTypes)
)
);
}
private void assertDynamicEventsHaveCorrectNames(
List<String> expectedEventNames,
List<DynamicGraphUpdatedEvent> actualEvents
) {
var actualEventsIterator = actualEvents.iterator();
expectedEventNames.forEach(expectedEventName ->
Assertions.assertEquals(
expectedEventName,
actualEventsIterator.next().getEventName(),
this.getDynamicEventsErrorMessage(expectedEventNames, actualEvents)
)
);
}
@NotNull
private String getDynamicEventsErrorMessage(
List<String> expectedEventNames,
List<DynamicGraphUpdatedEvent> actualEvents
) {
return "Expected event names dont match.\nExpected: %s\nActual: %s".formatted(
expectedEventNames,
actualEvents.stream()
.map(DynamicGraphUpdatedEvent::getEventName)
.toList()
);
}
private List<Class<?>> getActualEventTypes(TrackingEventStream actualEventStream) {
var actualEventTypes = new ArrayList<Class<?>>();
while (actualEventStream.hasNextAvailable()) {
actualEventTypes.add(getActualEventType(actualEventStream));
}
actualEventStream.close();
return actualEventTypes;
}
public List<Object> getActualEvents(TrackingEventStream actualEventStream) {
var actualEvents = new ArrayList<>();
while (actualEventStream.hasNextAvailable()) {
actualEvents.add(getActualEvent(actualEventStream));
}
actualEventStream.close();
return actualEvents;
}
private Object getActualEvent(TrackingEventStream actualEventStream) {
try {
return actualEventStream.nextAvailable().getPayload();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}
private List<TrackedEventMessage<?>> getActualEventMessages(
TrackingEventStream actualEventStream
) {
var actualEvents = new ArrayList<TrackedEventMessage<?>>();
while (actualEventStream.hasNextAvailable()) {
actualEvents.add(getActualEventMessage(actualEventStream));
}
actualEventStream.close();
return actualEvents;
}
private TrackedEventMessage<?> getActualEventMessage(TrackingEventStream actualEventStream) {
try {
return actualEventStream.nextAvailable();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}
private Class<?> getActualEventType(TrackingEventStream actualEventStream) {
try {
return actualEventStream.nextAvailable().getPayloadType();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}
protected String getErrorMessage(
List<Class<?>> expectedEventTypes,
List<Class<?>> actualEventTypes
) {
var title = LineFormatter.createLine("Actual event types differ from expected event types.");
var expectedTitle = LineFormatter.createLine("Expected:");
var expectedString = LineFormatter.createLines(
expectedEventTypes.stream().map(Class::toString)
);
var actualTitle = LineFormatter.createLine("Actual:");
var actualString = LineFormatter.createLines(
actualEventTypes.stream().map(Class::toString)
);
return title + expectedTitle + expectedString + actualTitle + actualString;
}
private String getErrorMessage(Class<?> expectedEventType, List<Class<?>> actualEventTypes) {
var title =
LineFormatter.createLine("Actual event types does not contain expected event type.");
var expectedTitle = LineFormatter.createLine("Expected:");
var expectedString = LineFormatter.createLine(expectedEventType.toString());
var actualTitle = LineFormatter.createLine("Actual:");
var actualString = LineFormatter.createLines(
actualEventTypes.stream().map(Class::toString)
);
return title + expectedTitle + expectedString + actualTitle + actualString;
}
private TrackingEventStream getActualEventStream() {
var token = eventStore.createTokenAt(this.testStartedAt);
return eventStore.openStream(token);
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/disabledImplementations/DisabledCommandGateway.java | package ai.stapi.test.disabledImplementations;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import org.axonframework.commandhandling.CommandCallback;
import org.axonframework.commandhandling.CommandMessage;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.common.Registration;
import org.axonframework.messaging.MessageDispatchInterceptor;
public class DisabledCommandGateway implements CommandGateway {
@Override
public <C, R> void send(C c, CommandCallback<? super C, ? super R> commandCallback) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowSendingCommands();
}
@Override
public <R> R sendAndWait(Object o) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowSendingCommands();
}
@Override
public <R> R sendAndWait(Object o, long l, TimeUnit timeUnit) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowSendingCommands();
}
@Override
public <R> CompletableFuture<R> send(Object o) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowSendingCommands();
}
@Override
public Registration registerDispatchInterceptor(
MessageDispatchInterceptor<? super CommandMessage<?>> messageDispatchInterceptor) {
return () -> false;
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/disabledImplementations/DisabledEventGateway.java | package ai.stapi.test.disabledImplementations;
import java.util.List;
import org.axonframework.common.Registration;
import org.axonframework.eventhandling.EventMessage;
import org.axonframework.eventhandling.gateway.EventGateway;
import org.axonframework.messaging.MessageDispatchInterceptor;
import org.jetbrains.annotations.NotNull;
public class DisabledEventGateway implements EventGateway {
@Override
public void publish(@NotNull List<?> events) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowPublishingEvents();
}
@Override
public Registration registerDispatchInterceptor(
@NotNull MessageDispatchInterceptor<? super EventMessage<?>> dispatchInterceptor
) {
return () -> false;
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/disabledImplementations/DisabledQueryGateway.java | package ai.stapi.test.disabledImplementations;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
import org.axonframework.common.Registration;
import org.axonframework.messaging.MessageDispatchInterceptor;
import org.axonframework.messaging.responsetypes.ResponseType;
import org.axonframework.queryhandling.QueryGateway;
import org.axonframework.queryhandling.QueryMessage;
import org.axonframework.queryhandling.SubscriptionQueryBackpressure;
import org.axonframework.queryhandling.SubscriptionQueryResult;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.reactivestreams.Publisher;
public class DisabledQueryGateway implements QueryGateway {
@Override
public <R, Q> CompletableFuture<R> query(
@NotNull String queryName,
@NotNull Q query,
@NotNull ResponseType<R> responseType
) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowQuerying();
}
@Override
public <R, Q> Publisher<R> streamingQuery(
String queryName,
Q query,
Class<R> responseType
) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowQuerying();
}
@Override
public <R, Q> Stream<R> scatterGather(
@NotNull String queryName,
@NotNull Q query,
@NotNull ResponseType<R> responseType,
long timeout,
@NotNull TimeUnit timeUnit
) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowQuerying();
}
@Override
public <Q, I, U> SubscriptionQueryResult<I, U> subscriptionQuery(
@NotNull String queryName,
@NotNull Q query,
@NotNull ResponseType<I> initialResponseType,
@NotNull ResponseType<U> updateResponseType,
@Nullable SubscriptionQueryBackpressure backpressure,
int updateBufferSize
) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowQuerying();
}
@Override
public <Q, I, U> SubscriptionQueryResult<I, U> subscriptionQuery(
@NotNull String queryName,
@NotNull Q query,
@NotNull ResponseType<I> initialResponseType,
@NotNull ResponseType<U> updateResponseType,
int updateBufferSize
) {
throw InvalidTestOperation.becauseTestCaseDoesntAllowQuerying();
}
@Override
public Registration registerDispatchInterceptor(
@NotNull MessageDispatchInterceptor<? super QueryMessage<?, ?>> dispatchInterceptor
) {
return () -> false;
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/disabledImplementations/InvalidTestOperation.java | package ai.stapi.test.disabledImplementations;
public class InvalidTestOperation extends RuntimeException {
private InvalidTestOperation(String becauseMessage) {
super("Invalid operation during test, " + becauseMessage);
}
public static InvalidTestOperation becauseTestCaseDoesntAllowSendingCommands() {
return new InvalidTestOperation("because TestCase doesnt allow sending commands.");
}
public static InvalidTestOperation becauseTestCaseDoesntAllowPublishingEvents() {
return new InvalidTestOperation("because TestCase doesnt allow publishing events.");
}
public static InvalidTestOperation becauseTestCaseDoesntAllowQuerying() {
return new InvalidTestOperation("because TestCase doesnt allow querying.");
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/domain/AbstractDomainTestCase.java | package ai.stapi.test.domain;
import static org.junit.jupiter.api.Assertions.assertTrue;
import ai.stapi.graphsystem.messaging.command.Command;
import ai.stapi.graphsystem.messaging.command.EndpointCommand;
import ai.stapi.graphsystem.systemfixtures.model.SystemModelDefinitionsLoader;
import ai.stapi.test.base.AbstractAxonTestCase;
import ai.stapi.test.schemaintegration.StructureDefinitionScope;
import java.util.Map;
import java.util.Optional;
import org.axonframework.commandhandling.CommandExecutionException;
import org.axonframework.commandhandling.GenericCommandMessage;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.messaging.MetaData;
import org.junit.jupiter.api.Assertions;
import org.springframework.beans.factory.annotation.Autowired;
@StructureDefinitionScope(SystemModelDefinitionsLoader.SCOPE)
public abstract class AbstractDomainTestCase extends AbstractAxonTestCase {
@Autowired
private CommandGateway commandGateway;
private static boolean validCommandClass(Object deserializedObject) {
return deserializedObject instanceof Command || deserializedObject instanceof Map<?, ?>;
}
protected void givenCommandIsDispatched(Object command) {
commandGateway.sendAndWait(command);
}
protected void whenCommandIsDispatched(Object command) {
commandGateway.sendAndWait(command);
if (command instanceof GenericCommandMessage<?> genericCommandMessage) {
command = genericCommandMessage.getPayload();
}
this.thenCommandCanBeSerialized(command);
}
protected void whenCommandIsDispatched(Object command, MetaData metaData) {
commandGateway.sendAndWait(command, metaData);
this.thenCommandCanBeSerialized(command);
}
protected Optional<CommandExecutionException> whenCommandThrowingExceptionIsDispatched(
Object command) {
try {
commandGateway.sendAndWait(command);
} catch (CommandExecutionException e) {
return Optional.of(e);
}
return Optional.empty();
}
private void thenCommandCanBeSerialized(Object commandToSerialize) {
this.thenCommandCanBeSerializedWithXSStream(commandToSerialize);
if (commandToSerialize instanceof EndpointCommand) {
this.thenCommandCanBeSerializedWithJsonSerializer(commandToSerialize);
}
}
private void thenCommandCanBeSerializedWithXSStream(Object commandToSerialize) {
var serializedCommand = this.serializer.serialize(
commandToSerialize,
String.class
);
var deserializedObject = this.serializer.deserialize(serializedCommand);
assertTrue(
validCommandClass(deserializedObject),
deserializedObject.getClass() + " does not implement command interface."
);
Assertions.assertEquals(commandToSerialize.getClass(), deserializedObject.getClass());
//TODO: Make working equals
}
private void thenCommandCanBeSerializedWithJsonSerializer(Object commandToSerialize) {
var serializedCommand = this.serializer.serialize(commandToSerialize, String.class);
var deserializedObject = this.serializer.deserialize(serializedCommand);
assertTrue(
validCommandClass(deserializedObject),
deserializedObject.getClass() + " does not implement Command interface."
);
var deserializedCommand = (Command) deserializedObject;
Assertions.assertEquals(commandToSerialize.getClass(), deserializedCommand.getClass());
//TODO: Make working equals
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/domain/DomainTestCase.java | package ai.stapi.test.domain;
import org.junit.jupiter.api.Tag;
import org.springframework.context.annotation.Import;
@Import(DomainTestConfig.class)
@Tag("domain")
public abstract class DomainTestCase extends AbstractDomainTestCase {
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/domain/DomainTestConfig.java | package ai.stapi.test.domain;
import ai.stapi.test.disabledImplementations.DisabledQueryGateway;
import org.axonframework.config.ConfigurerModule;
import org.axonframework.eventhandling.PropagatingErrorHandler;
import org.axonframework.eventhandling.tokenstore.TokenStore;
import org.axonframework.eventhandling.tokenstore.inmemory.InMemoryTokenStore;
import org.axonframework.eventsourcing.eventstore.EmbeddedEventStore;
import org.axonframework.eventsourcing.eventstore.EventStorageEngine;
import org.axonframework.eventsourcing.eventstore.EventStore;
import org.axonframework.queryhandling.QueryGateway;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
@Profile("test")
public class DomainTestConfig {
@Bean
@Primary
public static QueryGateway createQueryGateway() {
return new DisabledQueryGateway();
}
@Bean
public static EventStore createEventStore(
EventStorageEngine eventStorageEngine
) {
return new EmbeddedEventStore.Builder().storageEngine(eventStorageEngine).build();
}
@Bean
public static EventStorageEngine createEventStorageEngine() {
return new TestInMemoryEventStorageEngine();
}
@Bean
@Primary
public static TokenStore createTokenStore() {
return new InMemoryTokenStore();
}
@Bean
public ConfigurerModule processorDefaultConfigurerModule() {
return configurer -> configurer.eventProcessing(
eventProcessingConfigurer -> eventProcessingConfigurer
.registerDefaultListenerInvocationErrorHandler(
configuration -> PropagatingErrorHandler.INSTANCE)
.usingSubscribingEventProcessors()
);
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/domain/TestInMemoryEventStorageEngine.java | package ai.stapi.test.domain;
import static org.axonframework.eventhandling.EventUtils.asTrackedEventMessage;
import java.time.Instant;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Optional;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import javax.annotation.Nonnull;
import org.axonframework.eventhandling.DomainEventMessage;
import org.axonframework.eventhandling.EventMessage;
import org.axonframework.eventhandling.GlobalSequenceTrackingToken;
import org.axonframework.eventhandling.TrackedEventMessage;
import org.axonframework.eventhandling.TrackingToken;
import org.axonframework.eventsourcing.eventstore.DomainEventStream;
import org.axonframework.eventsourcing.eventstore.EventStorageEngine;
import org.axonframework.messaging.unitofwork.CurrentUnitOfWork;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class TestInMemoryEventStorageEngine implements EventStorageEngine {
@SuppressWarnings("SortedCollectionWithNonComparableKeys")
private final NavigableMap<
TrackingToken,
TrackedEventMessage<?>
> events = new ConcurrentSkipListMap<>();
private final Map<String, List<DomainEventMessage<?>>> snapshots = new ConcurrentHashMap<>();
private final long offset;
public TestInMemoryEventStorageEngine() {
this.offset = 0L;
}
public void reset() {
this.events.clear();
this.snapshots.clear();
}
@Override
public void appendEvents(@Nonnull List<? extends EventMessage<?>> events) {
if (CurrentUnitOfWork.isStarted()) {
CurrentUnitOfWork.get().onPrepareCommit(uow -> storeEvents(events));
} else {
storeEvents(events);
}
}
private void storeEvents(List<? extends EventMessage<?>> events) {
synchronized (this.events) {
GlobalSequenceTrackingToken trackingToken = nextTrackingToken();
this.events.putAll(
IntStream.range(0, events.size())
.mapToObj(i -> asTrackedEventMessage(
(EventMessage<?>) events.get(i), trackingToken.offsetBy(i)
))
.collect(Collectors.toMap(TrackedEventMessage::trackingToken, Function.identity()))
);
}
}
@Override
public void storeSnapshot(DomainEventMessage<?> snapshot) {
snapshots.compute(snapshot.getAggregateIdentifier(), (aggregateId, snapshotsSoFar) -> {
if (snapshotsSoFar == null) {
CopyOnWriteArrayList<DomainEventMessage<?>> newSnapshots = new CopyOnWriteArrayList<>();
newSnapshots.add(snapshot);
return newSnapshots;
}
snapshotsSoFar.add(snapshot);
return snapshotsSoFar;
});
}
@Override
public Stream<? extends TrackedEventMessage<?>> readEvents(
@Nullable TrackingToken trackingToken,
boolean mayBlock
) {
return StreamSupport.stream(new MapEntrySpliterator(events, trackingToken), false);
}
@Override
public DomainEventStream readEvents(
@NotNull String aggregateIdentifier,
long firstSequenceNumber
) {
AtomicReference<Long> sequenceNumber = new AtomicReference<>();
Stream<? extends DomainEventMessage<?>> stream =
events.values().stream().filter(event -> event instanceof DomainEventMessage<?>)
.map(event -> (DomainEventMessage<?>) event)
.filter(event -> aggregateIdentifier.equals(event.getAggregateIdentifier())
&& event.getSequenceNumber() >= firstSequenceNumber)
.peek(event -> sequenceNumber.set(event.getSequenceNumber()));
return DomainEventStream.of(stream, sequenceNumber::get);
}
@Override
public Optional<DomainEventMessage<?>> readSnapshot(@NotNull String aggregateIdentifier) {
return snapshots.getOrDefault(aggregateIdentifier, Collections.emptyList())
.stream()
.max(Comparator.comparingLong(DomainEventMessage::getSequenceNumber));
}
@Override
public TrackingToken createTailToken() {
if (events.size() == 0) {
return null;
}
GlobalSequenceTrackingToken firstToken = (GlobalSequenceTrackingToken) events.firstKey();
return new GlobalSequenceTrackingToken(firstToken.getGlobalIndex() - 1);
}
@Override
public TrackingToken createHeadToken() {
if (events.size() == 0) {
return null;
}
return events.lastKey();
}
@Override
public TrackingToken createTokenAt(@Nonnull Instant dateTime) {
return events.values()
.stream()
.filter(event -> event.getTimestamp().equals(dateTime) || event.getTimestamp()
.isAfter(dateTime))
.min(Comparator.comparingLong(e -> ((GlobalSequenceTrackingToken) e.trackingToken())
.getGlobalIndex()))
.map(TrackedEventMessage::trackingToken)
.map(tt -> (GlobalSequenceTrackingToken) tt)
.map(tt -> new GlobalSequenceTrackingToken(tt.getGlobalIndex() - 1))
.map(tt -> (TrackingToken) tt)
.orElseGet(this::createHeadToken);
}
protected GlobalSequenceTrackingToken nextTrackingToken() {
return events.isEmpty()
? new GlobalSequenceTrackingToken(offset)
: ((GlobalSequenceTrackingToken) events.lastKey()).next();
}
private static class MapEntrySpliterator
extends Spliterators.AbstractSpliterator<TrackedEventMessage<?>> {
private final NavigableMap<TrackingToken, TrackedEventMessage<?>> source;
private TrackingToken lastToken;
public MapEntrySpliterator(NavigableMap<TrackingToken, TrackedEventMessage<?>> source,
TrackingToken trackingToken) {
super(Long.MAX_VALUE, Spliterator.ORDERED);
this.source = source;
this.lastToken = trackingToken;
}
@Override
public boolean tryAdvance(Consumer<? super TrackedEventMessage<?>> action) {
Map.Entry<TrackingToken, TrackedEventMessage<?>> next;
if (lastToken != null) {
next = source.higherEntry(lastToken);
} else {
next = source.firstEntry();
}
if (next != null) {
lastToken = next.getKey();
action.accept(next.getValue());
}
return next != null;
}
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/fixtureQueryTest/AbstractFixtureQueryTestCase.java | package ai.stapi.test.fixtureQueryTest;
import static org.junit.jupiter.api.Assertions.assertTrue;
import ai.stapi.graphsystem.messaging.query.Query;
import ai.stapi.graphsystem.messaging.query.Response;
import ai.stapi.graphsystem.systemfixtures.model.SystemModelDefinitionsLoader;
import ai.stapi.test.base.AbstractAxonTestCase;
import ai.stapi.test.schemaintegration.StructureDefinitionScope;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.thoughtworks.xstream.XStream;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.concurrent.ExecutionException;
import javax.annotation.Nullable;
import org.axonframework.messaging.responsetypes.ResponseTypes;
import org.axonframework.queryhandling.QueryGateway;
import org.axonframework.serialization.xml.XStreamSerializer;
import org.junit.jupiter.api.Assertions;
import org.springframework.beans.factory.annotation.Autowired;
@StructureDefinitionScope(SystemModelDefinitionsLoader.SCOPE)
public abstract class AbstractFixtureQueryTestCase extends AbstractAxonTestCase {
@Autowired
private QueryGateway queryGateway;
@Autowired
private ObjectMapper objectMapper;
@Autowired
private XStream xStream;
@Deprecated
protected void thenQueryWillReturnResponseOfType(
Query query,
Class<? extends Object> expectedResponseType
) {
var completableFuture = queryGateway.query(
query,
ResponseTypes.instanceOf(expectedResponseType)
);
Object actualEntity = null;
try {
actualEntity = completableFuture.get();
} catch (InterruptedException | ExecutionException e) {
Thread.currentThread().interrupt();
}
Assertions.assertNotNull(actualEntity);
}
protected <T> T whenQueryIsDispatched(
Query query,
Class<T> expectedResponseType
) {
var completableFuture = queryGateway.query(
query,
ResponseTypes.instanceOf(expectedResponseType)
);
T actualResponse = null;
try {
actualResponse = completableFuture.get();
} catch (InterruptedException | ExecutionException e) {
Thread.currentThread().interrupt();
}
Assertions.assertNotNull(actualResponse);
this.thenQueryCanBeSerialized(query);
if (actualResponse != null) {
this.thenResponseCanBeSerializedWithJsonSerializer(actualResponse);
}
return actualResponse;
}
@Nullable
protected <T> T whenNullableQueryIsDispatched(
Query query,
Class<T> expectedResponseType
) {
var completableFuture = queryGateway.query(
query,
ResponseTypes.instanceOf(expectedResponseType)
);
T actualResponse = null;
try {
actualResponse = completableFuture.get();
} catch (InterruptedException | ExecutionException e) {
Thread.currentThread().interrupt();
}
Assertions.assertNotNull(actualResponse);
this.thenQueryCanBeSerialized(query);
if (actualResponse != null) {
this.thenResponseCanBeSerializedWithJsonSerializer(actualResponse);
}
return actualResponse;
}
protected <T> List<T> whenQueryReturningListIsDispatched(
Query query,
Class<T> expectedResponseType
) {
var actualResponse = this.makeQueryReturningList(query, expectedResponseType);
if (actualResponse == null) {
Assertions.fail("Response is null");
throw new RuntimeException("Response is null");
}
this.thenQueryCanBeSerialized(query);
actualResponse.forEach(this::thenResponseCanBeSerializedWithJsonSerializer);
return actualResponse;
}
protected <T> List<T> givenQueryReturningListIsDispatched(
Query query,
Class<T> expectedResponseType
) {
return makeQueryReturningList(query, expectedResponseType);
}
private <T> List<T> makeQueryReturningList(Query query, Class<T> expectedResponseType) {
var completableFuture = queryGateway.query(
query,
ResponseTypes.multipleInstancesOf(expectedResponseType)
);
List<T> actualResponse = null;
try {
actualResponse = completableFuture.get();
} catch (InterruptedException | ExecutionException e) {
Thread.currentThread().interrupt();
}
Assertions.assertNotNull(actualResponse);
return actualResponse;
}
private void thenQueryCanBeSerialized(Object queryToSerialize) {
this.thenQueryCanBeSerializedWithXStream(queryToSerialize);
this.thenQueryCanBeSerializedWithJsonSerializer(queryToSerialize);
}
private void thenQueryCanBeSerializedWithXStream(Object queryToSerialize) {
var serializer = XStreamSerializer.builder().xStream(this.xStream).build();
var serializedQuery = serializer.serialize(
queryToSerialize,
String.class
);
var deserializedObject = serializer.deserialize(serializedQuery);
assertTrue(
deserializedObject instanceof Query,
deserializedObject.getClass() + " does not implement query interface."
);
var deserializedQuery = (Query) deserializedObject;
Assertions.assertEquals(queryToSerialize.getClass(), deserializedQuery.getClass());
//TODO: Make working equals
}
private void thenQueryCanBeSerializedWithJsonSerializer(Object queryToSerialize) {
var serializer = this.objectMapper;
serializer.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
String serializedQuery;
try {
serializedQuery = serializer.writeValueAsString(queryToSerialize);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
Object deserializedObject;
try {
deserializedObject = serializer.readValue(serializedQuery, queryToSerialize.getClass());
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
assertTrue(
deserializedObject instanceof Query,
deserializedObject.getClass() + " does not implement query interface."
);
var deserializedQuery = (Query) deserializedObject;
Assertions.assertEquals(queryToSerialize.getClass(), deserializedQuery.getClass());
//TODO: Make working equals
}
private void thenResponseCanBeSerializedWithJsonSerializer(Object responseToSerialize) {
var serializer = this.objectMapper;
serializer.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
try {
serializer.writeValueAsString(responseToSerialize);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
assertTrue(
responseToSerialize instanceof Response
|| responseToSerialize instanceof LinkedHashMap<?, ?>,
responseToSerialize.getClass() + " does not implement the \"Response\" interface. \n " +
"Object returned from query must implement \"" + Response.class + "\" interface."
);
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/fixtureQueryTest/FixtureQueryTestCase.java | package ai.stapi.test.fixtureQueryTest;
import org.junit.jupiter.api.Tag;
import org.springframework.context.annotation.Import;
@Tag("fixture_query")
@Import(FixtureQueryTestCaseConfig.class)
public abstract class FixtureQueryTestCase extends AbstractFixtureQueryTestCase {
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/fixtureQueryTest/FixtureQueryTestCaseConfig.java | package ai.stapi.test.fixtureQueryTest;
import ai.stapi.graphoperations.synchronization.DisabledGraphSynchronizer;
import ai.stapi.graphoperations.synchronization.GraphSynchronizer;
import ai.stapi.graphsystem.aggregatedefinition.infrastructure.AdHocAggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.infrastructure.DatabaseAggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.infrastructure.AdHocOperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.infrastructure.DatabaseOperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.structuredefinition.loader.CombinedStructureDefinitionLoader;
import ai.stapi.graphsystem.structuredefinition.loader.SystemAdHocStructureDefinitionLoader;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import ai.stapi.test.disabledImplementations.DisabledCommandGateway;
import ai.stapi.test.disabledImplementations.DisabledEventGateway;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.eventhandling.gateway.EventGateway;
import org.axonframework.eventhandling.tokenstore.TokenStore;
import org.axonframework.eventhandling.tokenstore.inmemory.InMemoryTokenStore;
import org.axonframework.eventsourcing.eventstore.EmbeddedEventStore;
import org.axonframework.eventsourcing.eventstore.EventStore;
import org.axonframework.eventsourcing.eventstore.inmemory.InMemoryEventStorageEngine;
import org.axonframework.queryhandling.QueryBus;
import org.axonframework.queryhandling.SimpleQueryBus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
@Profile("test")
public class FixtureQueryTestCaseConfig {
@Bean
public static StructureDefinitionLoader structureDefinitionLoader(
CombinedStructureDefinitionLoader combinedStructureDefinitionLoader,
SystemAdHocStructureDefinitionLoader adHocStructureDefinitionLoader
) {
return combinedStructureDefinitionLoader;
}
@Bean
public static OperationDefinitionProvider operationDefinitionProvider(
@Autowired DatabaseOperationDefinitionProvider databaseOperationDefinitionProvider,
AdHocOperationDefinitionProvider adHocOperationDefinitionProvider
) {
return databaseOperationDefinitionProvider;
}
@Bean
public static AggregateDefinitionProvider aggregateDefinitionProvider(
@Autowired DatabaseAggregateDefinitionProvider databaseAggregateDefinitionProvider,
AdHocAggregateDefinitionProvider adHocAggregateDefinitionProvider
) {
return databaseAggregateDefinitionProvider;
}
@Bean
@Primary
public static GraphSynchronizer createDisabledSynchronizer() {
return new DisabledGraphSynchronizer();
}
@Bean
@Primary
public static QueryBus createQueryBus() {
return new SimpleQueryBus.Builder().build();
}
@Bean
public static EventStore createEventStore() {
return new EmbeddedEventStore.Builder().storageEngine(new InMemoryEventStorageEngine()).build();
}
@Bean
@Primary
public static EventGateway createEventGateway() {
return new DisabledEventGateway();
}
@Bean
@Primary
public static CommandGateway createCommandBus() {
return new DisabledCommandGateway();
}
@Bean
@Primary
public static TokenStore createTokenStore() {
return new InMemoryTokenStore();
}
}
|
0 | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test | java-sources/ai/stapi/axon-test/0.2.3/ai/stapi/test/systemschema/SystemSchemaIntegrationTestCase.java | package ai.stapi.test.systemschema;
import ai.stapi.graphsystem.systemfixtures.model.SystemModelDefinitionsLoader;
import ai.stapi.test.schemaintegration.SchemaIntegrationTestCase;
import ai.stapi.test.schemaintegration.StructureDefinitionScope;
@StructureDefinitionScope(SystemModelDefinitionsLoader.SCOPE)
public class SystemSchemaIntegrationTestCase extends SchemaIntegrationTestCase {
}
|
0 | java-sources/ai/stapi/base-test/0.3.2/ai/stapi | java-sources/ai/stapi/base-test/0.3.2/ai/stapi/test/FixtureFileLoadableTestTrait.java | package ai.stapi.test;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
public interface FixtureFileLoadableTestTrait {
default String getFixtureFilePath(String fixtureFile) {
var relativeTestFolderPath = this.getRelativeTestFolderPath();
return this.getAbsoluteFixturePath(
fixtureFile,
relativeTestFolderPath
);
}
default List<String> getAllFixtureFiles() {
var fixtureFolder = this.getFixtureFolder();
return new ArrayList<>(Arrays.stream(Objects.requireNonNull(fixtureFolder.listFiles()))
.filter(File::isFile)
.map(File::getAbsolutePath)
.toList());
}
default String getLocationFilePath() {
return System.getProperty("user.dir")
+ "/src/test/java/"
+ this.getRelativeTestFolderPath();
}
default File getFixtureFolder() {
return new File(
System.getProperty("user.dir") +
"/src/test/java/" +
this.getRelativeTestFolderPath() +
"/fixtures"
);
}
default String getAbsoluteFixturePath(
String fixtureFile,
String relativeTestFolderPath
) {
return System.getProperty("user.dir") +
"/src/test/java/" +
relativeTestFolderPath +
"/fixtures/" +
fixtureFile;
}
default String getRelativeTestFolderPath() {
var canonicalName = this.getClass().getCanonicalName();
var split = canonicalName.split("\\.");
return String.join(
"/",
Arrays.copyOfRange(
canonicalName.split("\\."),
0,
split.length - 1
)
);
}
}
|
0 | java-sources/ai/stapi/base-test/0.3.2/ai/stapi/test | java-sources/ai/stapi/base-test/0.3.2/ai/stapi/test/base/AbstractUnitTestCase.java | package ai.stapi.test.base;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.IdLessTextGraphRenderer;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.IdLessTextRendererOptions;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.attribute.TextAttributeContainerRenderer;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.edge.IdLessTextEdgeRenderer;
import ai.stapi.graph.renderer.infrastructure.idLessTextRenderer.node.IdLessTextNodeRenderer;
import ai.stapi.graph.renderer.infrastructure.textRenderer.edge.TextEdgeRenderer;
import ai.stapi.graph.renderer.infrastructure.textRenderer.node.TextNodeRenderer;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.objectRenderer.infrastructure.objectToJsonStringRenderer.ObjectToJSonStringOptions;
import ai.stapi.objectRenderer.infrastructure.objectToJsonStringRenderer.ObjectToJsonStringRenderer;
import ai.stapi.test.FixtureFileLoadableTestTrait;
import ai.stapi.utils.LineFormatter;
import java.util.ArrayList;
import java.util.List;
import org.approvaltests.Approvals;
import org.approvaltests.core.Options;
import org.approvaltests.reporters.JunitReporter;
import org.approvaltests.reporters.UseReporter;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.function.Executable;
@UseReporter(JunitReporter.class)
public abstract class AbstractUnitTestCase implements FixtureFileLoadableTestTrait {
private final TextAttributeContainerRenderer textAttributeContainerRenderer =
new TextAttributeContainerRenderer();
protected IdLessTextNodeRenderer idLessTextNodeRenderer = new IdLessTextNodeRenderer(
textAttributeContainerRenderer
);
protected TextNodeRenderer textNodeRenderer = new TextNodeRenderer(
idLessTextNodeRenderer
);
protected IdLessTextEdgeRenderer idLessTextEdgeRenderer = new IdLessTextEdgeRenderer(
textAttributeContainerRenderer
);
protected IdLessTextGraphRenderer idLessTextGraphRenderer =
new IdLessTextGraphRenderer(
idLessTextNodeRenderer, idLessTextEdgeRenderer
);
protected TextEdgeRenderer textEdgeRenderer = new TextEdgeRenderer(
idLessTextEdgeRenderer
);
protected IdLessTextGraphRenderer graphRenderer =
new IdLessTextGraphRenderer(
idLessTextNodeRenderer,
idLessTextEdgeRenderer
);
protected ObjectToJsonStringRenderer objectToJsonStringRenderer =
new ObjectToJsonStringRenderer();
protected void thenGraphApproved(Graph actualGraph) {
this.thenGraphApproved(new InMemoryGraphRepository(actualGraph));
}
protected void thenGraphApproved(InMemoryGraphRepository actualGraph) {
var textRenderedGraph = idLessTextGraphRenderer.render(
actualGraph,
this.getRenderOptions()
).toPrintableString();
Approvals.verify(textRenderedGraph, "txt");
}
protected void thenGraphApproved(Graph actualGraph, Options options) {
this.thenGraphApproved(
new InMemoryGraphRepository(actualGraph),
options
);
}
protected void thenGraphApproved(InMemoryGraphRepository actualGraph,
Options options) {
var textRenderedGraph = idLessTextGraphRenderer.render(
actualGraph,
this.getRenderOptions()
).toPrintableString();
Approvals.verify(textRenderedGraph, "txt", options);
}
protected void thenNodeApproved(TraversableNode node) {
Assertions.assertNotNull(node);
var renderedNode = idLessTextNodeRenderer.render(node).toPrintableString();
Approvals.verify(renderedNode);
}
protected void thenNodesApproved(List<TraversableNode> nodes) {
Assertions.assertNotNull(nodes);
if (nodes.size() == 0) {
Approvals.verify(new ArrayList<>());
return;
}
var renderedNodes = nodes.stream()
.map(node -> idLessTextNodeRenderer.render(node).toPrintableString())
.sorted();
Approvals.verify(LineFormatter.createLines(renderedNodes));
}
protected void thenUnsortedNodesApproved(List<TraversableNode> nodes) {
Assertions.assertNotNull(nodes);
if (nodes.size() == 0) {
Approvals.verify(new ArrayList<>());
return;
}
var renderedNodes = nodes.stream()
.map(node -> idLessTextNodeRenderer.render(node).toPrintableString());
Approvals.verify(LineFormatter.createLines(renderedNodes));
}
protected void thenGraphElementApproved(TraversableGraphElement graphElement) {
if (graphElement instanceof TraversableNode node) {
this.thenNodeApproved(node);
return;
}
if (graphElement instanceof TraversableEdge edge) {
this.thenEdgeApproved(edge);
return;
}
Assertions.fail("This should never happen.");
}
protected void thenGraphElementsApproved(List<TraversableGraphElement> graphElements) {
Assertions.assertNotNull(graphElements);
if (graphElements.size() == 0) {
Approvals.verify(new ArrayList<>());
return;
}
if (graphElements.get(0) instanceof TraversableNode) {
var nodes = graphElements.stream().map(node -> (TraversableNode) node).toList();
this.thenNodesApproved(nodes);
}
if (graphElements.get(0) instanceof TraversableEdge) {
var edges = graphElements.stream().map(edge -> (TraversableEdge) edge).toList();
this.thenEdgesApproved(edges);
}
}
protected void thenUnsortedGraphElementsApproved(List<TraversableGraphElement> graphElements) {
Assertions.assertNotNull(graphElements);
if (graphElements.size() == 0) {
Approvals.verify(new ArrayList<>());
return;
}
if (graphElements.get(0) instanceof TraversableNode) {
var nodes = graphElements.stream().map(node -> (TraversableNode) node).toList();
this.thenUnsortedNodesApproved(nodes);
}
if (graphElements.get(0) instanceof TraversableEdge) {
var edges = graphElements.stream().map(edge -> (TraversableEdge) edge).toList();
this.thenUnsortedEdgesApproved(edges);
}
}
protected void thenEdgeApproved(TraversableEdge edge) {
var renderEdge =
idLessTextEdgeRenderer.render(edge, this.getRenderOptions()).toPrintableString();
Approvals.verify(renderEdge);
}
protected void thenEdgesApproved(List<TraversableEdge> edges) {
Assertions.assertNotNull(edges);
if (edges.size() == 0) {
Approvals.verify(new ArrayList<>());
return;
}
var renderedEdges = edges.stream()
.map(edge -> idLessTextEdgeRenderer.render(edge).toPrintableString())
.sorted();
Approvals.verify(LineFormatter.createLines(renderedEdges));
}
protected void thenUnsortedEdgesApproved(List<TraversableEdge> edges) {
Assertions.assertNotNull(edges);
if (edges.size() == 0) {
Approvals.verify(new ArrayList<>());
return;
}
var renderedEdges = edges.stream()
.map(edge -> idLessTextEdgeRenderer.render(edge).toPrintableString());
Approvals.verify(LineFormatter.createLines(renderedEdges));
}
protected void thenIdLessGraphsAreEqual(
Graph expected,
Graph actual
) {
this.thenIdLessGraphsAreEqual(
new InMemoryGraphRepository(expected),
new InMemoryGraphRepository(actual)
);
}
protected void thenIdLessGraphsAreEqual(
InMemoryGraphRepository expected,
InMemoryGraphRepository actual
) {
var renderedExpected =
idLessTextGraphRenderer.render(expected, this.getRenderOptions())
.toPrintableString();
var renderedActual = idLessTextGraphRenderer.render(actual, this.getRenderOptions())
.toPrintableString();
Assertions.assertEquals(
renderedExpected,
renderedActual
);
}
protected void thenNodesAreSame(Node expectedNode, TraversableNode actualNode) {
var traversableExpectedNode = new Graph(expectedNode)
.traversable()
.loadNode(expectedNode.getId(), expectedNode.getType());
var renderedExpected = textNodeRenderer.render(traversableExpectedNode).toPrintableString();
var renderedActual = textNodeRenderer.render(actualNode).toPrintableString();
Assertions.assertEquals(
renderedExpected,
renderedActual
);
}
protected void thenEdgesAreSame(Edge expectedEdge, TraversableEdge actualEdge) {
var traversableExpectedEdge = new Graph(
new Node(expectedEdge.getNodeFromId(), expectedEdge.getNodeFromType()),
new Node(expectedEdge.getNodeToId(), expectedEdge.getNodeToType()),
expectedEdge
).traversable().loadEdge(expectedEdge.getId(), expectedEdge.getType());
var renderedExpected = textEdgeRenderer.render(traversableExpectedEdge).toPrintableString();
var renderedActual = textEdgeRenderer.render(actualEdge).toPrintableString();
Assertions.assertEquals(
renderedExpected,
renderedActual
);
}
protected void thenGraphsAreSame(
Graph expectedGraph,
Graph actualGraph
) {
this.thenGraphsAreSame(
new InMemoryGraphRepository(expectedGraph),
new InMemoryGraphRepository(actualGraph)
);
}
protected void thenGraphsAreSame(
InMemoryGraphRepository expectedGraph,
InMemoryGraphRepository actualGraph
) {
var renderedExpected = idLessTextGraphRenderer.render(
expectedGraph,
this.getRenderOptions()
).toPrintableString();
var renderedActual = idLessTextGraphRenderer.render(
actualGraph,
this.getRenderOptions()
).toPrintableString();
Assertions.assertEquals(
renderedExpected,
renderedActual
);
}
protected void thenEdgesHaveSameIdAndTypeAndNodeIds(Edge expectedEdge,
TraversableEdge actualEdge) {
Assertions.assertEquals(
expectedEdge.getId(),
actualEdge.getId(),
"Edges have different EdgeIds."
);
Assertions.assertEquals(
expectedEdge.getType(),
actualEdge.getType(),
"Edges have different type."
);
Assertions.assertEquals(
expectedEdge.getNodeFromId(),
actualEdge.getNodeFrom().getId(),
"Edges have different NodeFrom Id."
);
Assertions.assertEquals(
expectedEdge.getNodeToId(),
actualEdge.getNodeTo().getId(),
"Edges have different NodeTo Id."
);
}
protected void thenObjectApproved(Object obj) {
var options = new ObjectToJSonStringOptions(
ObjectToJSonStringOptions.RenderFeature.SORT_FIELDS,
ObjectToJSonStringOptions.RenderFeature.HIDE_IDS
);
this.thenObjectApproved(obj, options);
}
protected void thenObjectApproved(
Object obj,
ObjectToJSonStringOptions.RenderFeature... features
) {
var options = new ObjectToJSonStringOptions(features);
this.thenObjectApproved(obj, options);
}
protected void thenObjectApproved(
Object obj,
List<ObjectToJSonStringOptions.RenderFeature> features
) {
var options = new ObjectToJSonStringOptions(features);
this.thenObjectApproved(obj, options);
}
protected void thenObjectApprovedWithoutSorting(Object obj) {
var options = new ObjectToJSonStringOptions(ObjectToJSonStringOptions.RenderFeature.HIDE_IDS);
this.thenObjectApproved(obj, options);
}
protected void thenObjectApprovedWithShownIds(Object obj) {
var options =
new ObjectToJSonStringOptions(ObjectToJSonStringOptions.RenderFeature.SORT_FIELDS);
this.thenObjectApproved(obj, options);
}
protected void thenObjectApproved(Object obj, ObjectToJSonStringOptions options) {
var objRender = this.objectToJsonStringRenderer.render(obj, options);
Approvals.verify(objRender.toPrintableString().replace("\\n", System.lineSeparator()));
}
protected void thenStringApproved(String actual) {
Approvals.verify(actual.replace("\\n", System.lineSeparator()));
}
protected void thenObjectsEquals(Object expected, Object actual,
ObjectToJSonStringOptions options) {
var expectedRender = this.objectToJsonStringRenderer.render(expected, options);
var actualRender = this.objectToJsonStringRenderer.render(actual, options);
Assertions.assertEquals(expectedRender.toPrintableString(), actualRender.toPrintableString(),
"Objects do not match!");
}
protected void thenObjectsEquals(Object expected, Object actual) {
this.thenObjectsEquals(
expected,
actual,
new ObjectToJSonStringOptions(
ObjectToJSonStringOptions.RenderFeature.HIDE_IDS,
ObjectToJSonStringOptions.RenderFeature.SORT_FIELDS
)
);
}
protected <T extends Throwable> T thenExceptionMessageApprovedWithHiddenUuids(
Class<T> exception,
Executable throwable
) {
var error = Assertions.assertThrows(exception, throwable);
var toApprove = error.getMessage().replaceAll("([a-f0-9]{8}(-[a-f0-9]{4}){4}[a-f0-9]{8})",
"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx");
Approvals.verify(toApprove);
return error;
}
protected <T extends Throwable> T thenExceptionMessageApproved(
Class<T> exception,
Executable throwable
) {
var error = Assertions.assertThrows(exception, throwable);
Approvals.verify(error.getMessage());
return error;
}
protected IdLessTextRendererOptions getRenderOptions() {
return new IdLessTextRendererOptions();
}
}
|
0 | java-sources/ai/stapi/base-test/0.3.2/ai/stapi/test | java-sources/ai/stapi/base-test/0.3.2/ai/stapi/test/base/UnitTestCase.java | package ai.stapi.test.base;
import org.junit.jupiter.api.Tag;
@Tag("unit")
public abstract class UnitTestCase extends AbstractUnitTestCase {
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.