index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph/deserializer/SerializableNodeDeserializer.java | package ai.stapi.graphoperations.serializableGraph.deserializer;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graphoperations.serializableGraph.SerializableNode;
import ai.stapi.identity.UniqueIdentifier;
import org.springframework.stereotype.Service;
public class SerializableNodeDeserializer {
private final SerializableAttributeDeserializer attributeDeserializer;
public SerializableNodeDeserializer(SerializableAttributeDeserializer attributeDeserializer) {
this.attributeDeserializer = attributeDeserializer;
}
public Node deserialize(SerializableNode serializableNode) {
return new Node(
new UniqueIdentifier(serializableNode.getId()),
serializableNode.getType(),
this.attributeDeserializer.deserializeGroup(
serializableNode.getType(),
serializableNode.getAttributes()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializableGraph/jackson/SerializableGraphConfigurer.java | package ai.stapi.graphoperations.serializableGraph.jackson;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graphoperations.serializableGraph.SerializableEdge;
import ai.stapi.graphoperations.serializableGraph.SerializableGraph;
import ai.stapi.graphoperations.serializableGraph.SerializableNode;
import ai.stapi.graphoperations.serializableGraph.deserializer.SerializableGraphDeserializer;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.module.SimpleModule;
import java.io.IOException;
public class SerializableGraphConfigurer {
private final SerializableGraphDeserializer serializableGraphDeserializer;
public SerializableGraphConfigurer(SerializableGraphDeserializer serializableGraphDeserializer) {
this.serializableGraphDeserializer = serializableGraphDeserializer;
}
public void configure(ObjectMapper objectMapper) {
var inMemoryGraphModule = new SimpleModule("InMemoryGraphModule");
inMemoryGraphModule.addSerializer(
Graph.class,
new JsonSerializer<>() {
@Override
public void serialize(
Graph value,
JsonGenerator gen,
SerializerProvider serializers
) throws IOException {
gen.writeObject(SerializableGraph.fromInMemory(value));
}
}
);
inMemoryGraphModule.addDeserializer(
Graph.class,
new JsonDeserializer<>() {
@Override
public Graph deserialize(
JsonParser p,
DeserializationContext ctxt
) throws IOException {
var serializableGraph = p.readValueAs(SerializableGraph.class);
return serializableGraphDeserializer.deserialize(serializableGraph);
}
}
);
inMemoryGraphModule.addSerializer(
Node.class,
new JsonSerializer<>() {
@Override
public void serialize(
Node value,
JsonGenerator gen,
SerializerProvider serializers
) throws IOException {
gen.writeObject(SerializableNode.fromInputNode(value));
}
}
);
inMemoryGraphModule.addDeserializer(
Node.class,
new JsonDeserializer<>() {
@Override
public Node deserialize(
JsonParser p,
DeserializationContext ctxt
) throws IOException {
var serializableNode = p.readValueAs(SerializableNode.class);
return serializableGraphDeserializer.deserializeNode(serializableNode);
}
}
);
inMemoryGraphModule.addSerializer(
Edge.class,
new JsonSerializer<>() {
@Override
public void serialize(
Edge value,
JsonGenerator gen,
SerializerProvider serializers
) throws IOException {
gen.writeObject(SerializableEdge.fromInputEdge(value));
}
}
);
inMemoryGraphModule.addDeserializer(
Edge.class,
new JsonDeserializer<>() {
@Override
public Edge deserialize(
JsonParser p,
DeserializationContext ctxt
) throws IOException {
var serializableEdge = p.readValueAs(SerializableEdge.class);
return serializableGraphDeserializer.deserializeEdge(serializableEdge);
}
}
);
objectMapper.registerModule(inMemoryGraphModule);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializationTypeProvider/GenericSerializationTypeByNodeProvider.java | package ai.stapi.graphoperations.serializationTypeProvider;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.serializationTypeProvider.exception.GenericSerializationTypeProviderException;
import ai.stapi.graphoperations.serializationTypeProvider.specific.SpecificSerializationTypeProvider;
import java.util.List;
import org.springframework.stereotype.Service;
public class GenericSerializationTypeByNodeProvider {
private final List<SpecificSerializationTypeProvider> serializationTypeProviders;
public GenericSerializationTypeByNodeProvider(
List<SpecificSerializationTypeProvider> serializationTypeProviders
) {
this.serializationTypeProviders = serializationTypeProviders;
}
public String getSerializationType(TraversableGraphElement element) {
var provider = this.getSupportingProvider(element);
return provider.provideSerializationType(element);
}
public boolean existsSerializationTypeForNode(TraversableGraphElement element) {
try {
this.getSupportingProvider(element);
return true;
} catch (GenericSerializationTypeProviderException ignore) {
return false;
}
}
private SpecificSerializationTypeProvider getSupportingProvider(TraversableGraphElement element) {
var supportingProviders = this.serializationTypeProviders.stream()
.filter(provider -> provider.supports(element))
.toList();
if (supportingProviders.size() == 0) {
throw GenericSerializationTypeProviderException.becauseThereIsNotSupportingProvider(element);
}
return supportingProviders.get(0);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializationTypeProvider | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializationTypeProvider/exception/GenericSerializationTypeProviderException.java | package ai.stapi.graphoperations.serializationTypeProvider.exception;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
public class GenericSerializationTypeProviderException extends RuntimeException {
private GenericSerializationTypeProviderException(String message) {
super(message);
}
public static GenericSerializationTypeProviderException becauseThereIsNotSupportingProvider(
TraversableGraphElement element) {
return new GenericSerializationTypeProviderException(
"There is not supporting provider for '"
+ element.getClass().getSimpleName()
+ "' graph element '"
+ element.getId()
+ "' of type '"
+ element.getType()
+ "'."
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializationTypeProvider | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializationTypeProvider/specific/ByMapSerializationTypeProvider.java | package ai.stapi.graphoperations.serializationTypeProvider.specific;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.BooleanAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IngoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.IntegerAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.LeafAttributeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.StringAttributeValueDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.removal.RemovalNodeDescription;
import ai.stapi.graphoperations.objectGraphLanguage.InterfaceObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.LeafObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ListObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.MapObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectFieldDefinition;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectObjectGraphMapping;
import ai.stapi.graphoperations.objectLanguage.EntityIdentifier;
import ai.stapi.graphoperations.ogmProviders.specific.objectGraphMappingMappingProviders.OgmGraphElementTypes;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.GraphDescriptionGraphElementTypes;
import ai.stapi.graphoperations.ogmProviders.specific.graphDescriptionMappingProviders.ObjectDeclarationGraphElementTypes;
import ai.stapi.schema.structuredefinition.ElementDefinition;
import ai.stapi.schema.structuredefinition.StructureDefinitionData;
import java.util.HashMap;
import java.util.Map;
public class ByMapSerializationTypeProvider implements SpecificSerializationTypeProvider {
@Override
public String provideSerializationType(TraversableGraphElement element) {
return this.mapOfSerializableNodeTypes().get(element.getType());
}
@Override
public boolean supports(TraversableGraphElement element) {
return this.mapOfSerializableNodeTypes().containsKey(element.getType());
}
private Map<String, String> mapOfSerializableNodeTypes() {
var map = new HashMap<String, String>();
map.put(OgmGraphElementTypes.OGM_OBJECT_NODE, ObjectObjectGraphMapping.SERIALIZATION_TYPE);
map.put(OgmGraphElementTypes.OGM_LEAF_NODE, LeafObjectGraphMapping.SERIALIZATION_TYPE);
map.put(OgmGraphElementTypes.OGM_MAP_NODE, MapObjectGraphMapping.SERIALIZATION_TYPE);
map.put(OgmGraphElementTypes.OGM_LIST_NODE, ListObjectGraphMapping.SERIALIZATION_TYPE);
map.put(OgmGraphElementTypes.OGM_OBJECT_FIELD_NODE, ObjectFieldDefinition.SERIALIZATION_TYPE);
map.put(
OgmGraphElementTypes.OGM_INTERFACE_NODE,
InterfaceObjectGraphMapping.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.NODE_DESCRIPTION_NODE,
NodeDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.INCOMING_EDGE_DESCRIPTION_NODE,
IngoingEdgeDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.OUTGOING_EDGE_DESCRIPTION_NODE,
OutgoingEdgeDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.UUID_DESCRIPTION,
UuidIdentityDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.BOOLEAN_ATTRIBUTE_DESCRIPTION,
BooleanAttributeValueDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.STRING_ATTRIBUTE_DESCRIPTION,
StringAttributeValueDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.INTEGER_ATTRIBUTE_DESCRIPTION,
IntegerAttributeValueDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.LEAF_ATTRIBUTE_DESCRIPTION,
LeafAttributeDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.REMOVAL_EDGE_DESCRIPTION,
RemovalEdgeDescription.SERIALIZATION_TYPE
);
map.put(
GraphDescriptionGraphElementTypes.REMOVAL_NODE_DESCRIPTION,
RemovalNodeDescription.SERIALIZATION_TYPE
);
map.put(
ObjectDeclarationGraphElementTypes.ENTITY_IDENTIFIER_DECLARATION,
EntityIdentifier.SERIALIZATION_TYPE
);
map.put(StructureDefinitionData.SERIALIZATION_TYPE, StructureDefinitionData.SERIALIZATION_TYPE);
map.put(ElementDefinition.SERIALIZATION_TYPE, ElementDefinition.SERIALIZATION_TYPE);
return map;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializationTypeProvider | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/serializationTypeProvider/specific/SpecificSerializationTypeProvider.java | package ai.stapi.graphoperations.serializationTypeProvider.specific;
import ai.stapi.graph.traversableGraphElements.TraversableGraphElement;
public interface SpecificSerializationTypeProvider {
String provideSerializationType(TraversableGraphElement element);
boolean supports(TraversableGraphElement element);
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/DisabledGraphSynchronizer.java | package ai.stapi.graphoperations.synchronization;
import ai.stapi.graph.Graph;
import ai.stapi.graph.exceptions.GraphException;
public class DisabledGraphSynchronizer implements GraphSynchronizer {
@Override
public void synchronize(Graph graph) throws GraphException {
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/GraphSynchronizer.java | package ai.stapi.graphoperations.synchronization;
import ai.stapi.graph.Graph;
import ai.stapi.graph.exceptions.GraphException;
public interface GraphSynchronizer {
void synchronize(Graph graph) throws GraphException;
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/IdentifyingGraphSynchronizer.java | package ai.stapi.graphoperations.synchronization;
import ai.stapi.graph.EdgeRepository;
import ai.stapi.graph.Graph;
import ai.stapi.graph.NodeIdAndType;
import ai.stapi.graph.NodeRepository;
import ai.stapi.graph.exceptions.GraphException;
import ai.stapi.graph.graphelements.Edge;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graph.inMemoryGraph.EdgeBuilder;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableEdge;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGenericSearchOptionResolver;
import ai.stapi.graphoperations.graphLoader.inmemory.InMemoryGraphLoader;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.NodeIdentifyingFiltersResolver;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections4.map.LinkedMap;
public class IdentifyingGraphSynchronizer implements GraphSynchronizer {
private final NodeRepository nodeRepository;
private final EdgeRepository edgeRepository;
private final NodeIdentifyingFiltersResolver nodeIdentifyingFiltersResolver;
private final GraphLoader graphLoader;
private final InMemoryGenericSearchOptionResolver searchOptionResolver;
private final ObjectMapper objectMapper;
private final StructureSchemaFinder structureSchemaFinder;
public IdentifyingGraphSynchronizer(
NodeRepository nodeRepository,
EdgeRepository edgeRepository,
NodeIdentifyingFiltersResolver nodeIdentifyingFiltersResolver,
GraphLoader graphLoader,
InMemoryGenericSearchOptionResolver searchOptionResolver,
ObjectMapper objectMapper,
StructureSchemaFinder structureSchemaFinder
) {
this.nodeRepository = nodeRepository;
this.edgeRepository = edgeRepository;
this.nodeIdentifyingFiltersResolver = nodeIdentifyingFiltersResolver;
this.graphLoader = graphLoader;
this.searchOptionResolver = searchOptionResolver;
this.objectMapper = objectMapper;
this.structureSchemaFinder = structureSchemaFinder;
}
@Override
public void synchronize(Graph graph) throws GraphException {
var newGraph = new InMemoryGraphRepository(graph);
var idChanges = this.synchronizeNodes(newGraph);
this.synchronizeEdges(newGraph, idChanges);
}
public InMemoryGraphRepository mergeDuplicateNodesByIdentificators(
InMemoryGraphRepository graphWithDuplications
) {
Map<UniqueIdentifier, Node> processedNodes = new LinkedMap<>();
var resultingGraph = new InMemoryGraphRepository();
var inMemoryGraphLoader = new InMemoryGraphLoader(
resultingGraph,
this.searchOptionResolver,
this.structureSchemaFinder,
this.objectMapper
);
for (Node mergingNode : graphWithDuplications.getGraph().getAllNodes()) {
var identifyingQuery = this.nodeIdentifyingFiltersResolver.resolve(
mergingNode,
graphWithDuplications
);
var identfiedNodes = inMemoryGraphLoader.findAsTraversable(identifyingQuery);
var sameTypeIdentifiedNodes = identfiedNodes.stream()
.map(TraversableNode.class::cast)
.map(Node::new)
.filter(graphNode -> mergingNode.getType().equals(graphNode.getType()))
.toList();
if (sameTypeIdentifiedNodes.isEmpty()) {
resultingGraph.save(mergingNode);
processedNodes.put(
mergingNode.getId(),
mergingNode
);
continue;
}
if (sameTypeIdentifiedNodes.size() == 1) {
var existingNode = sameTypeIdentifiedNodes.get(0);
var newNode = (Node) existingNode.mergeAttributesWithAttributesOf(mergingNode);
resultingGraph.replace(newNode);
processedNodes.put(mergingNode.getId(), newNode);
continue;
}
throw new GraphException(
"Multiple nodes found by identificators. This should never happen. " +
"If occurs, it MUST BE investigated."
);
}
List<Edge> fixedEdges = graphWithDuplications.loadAllEdges().stream().map(
oldEdge ->
{
Node fixedNodeFrom = processedNodes.get(oldEdge.getNodeFromId());
Node fixedNodeTo = processedNodes.get(oldEdge.getNodeToId());
return new EdgeBuilder()
.setEdgeId(oldEdge.getId())
.setEdgeType(oldEdge.getType())
.setNodeFromId(fixedNodeFrom.getId())
.setNodeToId(fixedNodeTo.getId())
.setNodeFromType(fixedNodeFrom.getType())
.setNodeToType(fixedNodeTo.getType())
.setVersionedAttributes(oldEdge.getVersionedAttributes())
.create();
}
).toList();
List<Edge> mergedEdges = new ArrayList<>();
fixedEdges.forEach(fixedEdge -> {
List<Edge> foundEdges = mergedEdges.stream().filter(processedEdge ->
processedEdge.getNodeFromId().equals(fixedEdge.getNodeFromId()) &&
processedEdge.getNodeToId().equals(fixedEdge.getNodeToId()) &&
processedEdge.getType().equals(fixedEdge.getType())
).toList();
if (foundEdges.isEmpty()) {
resultingGraph.save(fixedEdge);
mergedEdges.add(fixedEdge);
return;
}
if (foundEdges.size() == 1) {
Edge edge =
(Edge) foundEdges.get(0).mergeAttributesWithAttributesOf(fixedEdge);
resultingGraph.replace(edge);
return;
}
throw new GraphException("Multiple edges found by end nodes and attributes.");
});
return resultingGraph.getGraph().traversable();
}
private LinkedMap<String, LinkedMap<UniqueIdentifier, UniqueIdentifier>> synchronizeNodes(
InMemoryGraphRepository newGraph
) {
var nodeIdChangesMap = new LinkedMap<String, LinkedMap<UniqueIdentifier, UniqueIdentifier>>();
for (var node : newGraph.getGraph().getAllNodes()) {
this.synchronizeNode(
newGraph,
node,
nodeIdChangesMap
);
}
return nodeIdChangesMap;
}
private void synchronizeNode(
InMemoryGraphRepository newGraph,
Node inMemoryNode,
LinkedMap<String, LinkedMap<UniqueIdentifier, UniqueIdentifier>> nodeIdChangesMap
) {
var identifyingQuery = this.nodeIdentifyingFiltersResolver.resolve(
inMemoryNode,
newGraph
);
var foundNodes = this.graphLoader.findAsTraversable(identifyingQuery);
if (foundNodes.size() > 1) {
throw new GraphException(
"Multiple nodes found by identificators. This should never happen. " +
"If occurs, it MUST BE investigated."
);
}
if (foundNodes.isEmpty()) {
this.nodeRepository.save(
new Node(
inMemoryNode.getId(),
inMemoryNode.getType(),
inMemoryNode.getVersionedAttributes()
)
);
return;
}
var foundNode = (TraversableNode) foundNodes.get(0);
foundNode = (TraversableNode) foundNode.mergeAttributesWithAttributesOf(inMemoryNode);
this.nodeRepository.replace(
new Node(
foundNode.getId(),
foundNode.getType(),
foundNode.getVersionedAttributes()
)
);
var nodeTypeMap = nodeIdChangesMap.computeIfAbsent(inMemoryNode.getType(), (key) -> new LinkedMap<>());
nodeTypeMap.put(
inMemoryNode.getId(),
foundNode.getId()
);
}
private void synchronizeEdges(
InMemoryGraphRepository newGraph,
LinkedMap<String, LinkedMap<UniqueIdentifier, UniqueIdentifier>> nodeIdChangeMap
) {
newGraph.getGraph().getAllEdges().forEach(
potentiallyRottenEdge ->
{
var fixedNodeFromId = nodeIdChangeMap.getOrDefault(
potentiallyRottenEdge.getNodeFromType(),
new LinkedMap<>()
).getOrDefault(
potentiallyRottenEdge.getNodeFromId(),
potentiallyRottenEdge.getNodeFromId()
);
var fixedNodeFrom = new Node(fixedNodeFromId, potentiallyRottenEdge.getNodeFromType());
var fixedNodeToId = nodeIdChangeMap.getOrDefault(
potentiallyRottenEdge.getNodeToType(),
new LinkedMap<>()
).getOrDefault(
potentiallyRottenEdge.getNodeToId(),
potentiallyRottenEdge.getNodeToId()
);
var fixedNodeTo = new Node(fixedNodeToId, potentiallyRottenEdge.getNodeToType());
var fixedEdge = new Edge(
potentiallyRottenEdge.getId(),
fixedNodeFrom,
potentiallyRottenEdge.getType(),
fixedNodeTo
);
fixedEdge = (Edge) fixedEdge.mergeAttributesWithAttributesOf(potentiallyRottenEdge);
var foundEdge = edgeRepository.findEdgeByTypeAndNodes(
fixedEdge.getType(),
new NodeIdAndType(fixedEdge.getNodeFromId(), fixedEdge.getNodeFromType()),
new NodeIdAndType(fixedEdge.getNodeToId(), fixedEdge.getNodeToType())
);
if (foundEdge != null) {
foundEdge = (TraversableEdge) foundEdge.mergeAttributesWithAttributesOf(fixedEdge);
edgeRepository.replace(
new Edge(
foundEdge.getId(),
foundEdge.getType(),
new Node(foundEdge.getNodeFrom().getId(), foundEdge.getNodeFrom().getType()),
new Node(foundEdge.getNodeTo().getId(), foundEdge.getNodeTo().getType()),
foundEdge.getVersionedAttributes()
)
);
} else {
edgeRepository.save(fixedEdge);
}
}
);
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/ReplacingGraphSynchronizer.java | package ai.stapi.graphoperations.synchronization;
import ai.stapi.graph.EdgeRepository;
import ai.stapi.graph.Graph;
import ai.stapi.graph.NodeRepository;
import ai.stapi.graph.exceptions.GraphException;
public class ReplacingGraphSynchronizer implements GraphSynchronizer {
private final NodeRepository nodeRepository;
private final EdgeRepository edgeRepository;
public ReplacingGraphSynchronizer(
NodeRepository nodeRepository,
EdgeRepository edgeRepository
) {
this.nodeRepository = nodeRepository;
this.edgeRepository = edgeRepository;
}
@Override
public void synchronize(Graph graph) throws GraphException {
graph.getAllNodes().forEach(node -> {
if (this.nodeRepository.nodeExists(node.getId(), node.getType())) {
this.nodeRepository.replace(node);
} else {
this.nodeRepository.save(node);
}
});
graph.getAllEdges().forEach(edge -> {
if (this.edgeRepository.edgeExists(edge.getId(), edge.getType())) {
this.edgeRepository.replace(edge);
} else {
this.edgeRepository.save(edge);
}
});
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/nodeIdentificator/DefaultUuidIdentityIdentificatorProvider.java | package ai.stapi.graphoperations.synchronization.nodeIdentificator;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import java.util.List;
public class DefaultUuidIdentityIdentificatorProvider implements NodeIdentificatorsProvider {
@Override
public List<NodeIdentificator> provide(String nodeType) {
return List.of(
new NodeIdentificator(new UuidIdentityDescription())
);
}
@Override
public boolean supports(String nodeType) {
return true;
}
@Override
public int priority() {
return NodeIdentificatorsProvider.MAX_PRIORITY;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/nodeIdentificator/GenericNodeIdentificatorsProvider.java | package ai.stapi.graphoperations.synchronization.nodeIdentificator;
import java.util.Comparator;
import java.util.List;
import org.springframework.stereotype.Service;
public class GenericNodeIdentificatorsProvider {
private final List<NodeIdentificatorsProvider> providers;
public GenericNodeIdentificatorsProvider(List<NodeIdentificatorsProvider> providers) {
this.providers = providers;
}
public List<NodeIdentificator> provide(String nodeType) {
return this.providers.stream()
.filter(provider -> provider.supports(nodeType))
.sorted(Comparator.comparingInt(NodeIdentificatorsProvider::priority).reversed())
.flatMap(provider -> provider.provide(nodeType).stream())
.toList();
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/nodeIdentificator/NodeIdentificator.java | package ai.stapi.graphoperations.synchronization.nodeIdentificator;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AbstractNodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.synchronization.nodeIdentificator.exception.InvalidNodeIdentificator;
import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class NodeIdentificator implements Serializable {
private final List<PositiveGraphDescription> graphDescriptions;
public NodeIdentificator(String... attributeNames) {
this(Arrays.stream(attributeNames).map(AttributeQueryDescription::new).collect(Collectors.toList()));
}
public NodeIdentificator(PositiveGraphDescription graphDescription) {
this(List.of(graphDescription));
}
public NodeIdentificator(List<PositiveGraphDescription> graphDescriptions) {
var invalidStart = graphDescriptions.stream()
.filter(AbstractNodeDescription.class::isInstance)
.toList();
if (!invalidStart.isEmpty()) {
throw InvalidNodeIdentificator.becausePathToIdentifiactionValueDoesntStartWithEdgeOrAttributeDescription(
invalidStart
);
}
var invalidBranching = graphDescriptions.stream()
.filter(description -> !GraphDescriptionBuilder.isGraphDescriptionSinglePath(description))
.toList();
if (!invalidBranching.isEmpty()) {
throw InvalidNodeIdentificator.becausePathToIdentifiactionValueIsNotSinglePath(
invalidBranching
);
}
var invalidEnd = graphDescriptions.stream()
.filter(desc -> !GraphDescriptionBuilder.isGraphDescriptionEndingWithAttributeOrUuidDescription(desc))
.toList();
if (!invalidEnd.isEmpty()) {
throw InvalidNodeIdentificator.becausePathToIdentifiactionValueIsNotEndingWithUuidIdentityOrAttributeDescription(
invalidEnd
);
}
this.graphDescriptions = graphDescriptions;
}
public List<PositiveGraphDescription> getGraphDescriptions() {
return graphDescriptions;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/nodeIdentificator/NodeIdentificatorsProvider.java | package ai.stapi.graphoperations.synchronization.nodeIdentificator;
import java.util.List;
public interface NodeIdentificatorsProvider {
int MAX_PRIORITY = 1000;
int MIN_PRIORITY = -1000;
int DEFAULT_PRIORITY = 0;
List<NodeIdentificator> provide(String nodeType);
boolean supports(String nodeType);
default int priority() {
return DEFAULT_PRIORITY;
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/nodeIdentificator/NodeIdentifyingFiltersResolver.java | package ai.stapi.graphoperations.synchronization.nodeIdentificator;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.AllAttributesDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.NodeQueryGraphDescription;
import ai.stapi.graphoperations.graphLoader.search.SearchQueryParameters;
import ai.stapi.graphoperations.graphLoader.search.filterOption.AndFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.EqualsFilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOption;
import ai.stapi.graphoperations.graphLoader.search.filterOption.FilterOptionParameters;
import ai.stapi.graphoperations.graphLoader.search.filterOption.OrFilterOption;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.OffsetPaginationOption;
import ai.stapi.graphoperations.graphReader.GraphReader;
import java.util.List;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
import org.springframework.stereotype.Service;
public class NodeIdentifyingFiltersResolver {
private final GenericNodeIdentificatorsProvider identificatorsProvider;
private final GraphReader graphReader;
public NodeIdentifyingFiltersResolver(
GenericNodeIdentificatorsProvider identificatorsProvider,
GraphReader graphReader
) {
this.identificatorsProvider = identificatorsProvider;
this.graphReader = graphReader;
}
public NodeQueryGraphDescription resolve(
Node node,
InMemoryGraphRepository contextGraph
) {
var filters = this.resolveFilters(node, contextGraph);
return new NodeQueryGraphDescription(
new NodeDescriptionParameters(node.getType()),
SearchQueryParameters.builder()
.addFilterOption(filters.size() == 1 ? filters.get(0) : new OrFilterOption(filters))
.setPaginationOption(new OffsetPaginationOption(0, 2))
.build(),
new AllAttributesDescription()
);
}
private List<FilterOption<?>> resolveFilters(Node node, InMemoryGraphRepository contextGraph) {
var identificators = this.identificatorsProvider.provide(node.getType());
return identificators.stream()
.map(NodeIdentificator::getGraphDescriptions)
.map(descriptions -> this.readByDescriptions(node, contextGraph, descriptions))
.filter(readOutputs -> readOutputs.stream().noneMatch(ReadOutput::isEmpty))
.map(this::mapToFilterOption)
.collect(Collectors.toList());
}
@NotNull
private List<ReadOutput> readByDescriptions(
Node node,
InMemoryGraphRepository contextGraph,
List<PositiveGraphDescription> descriptions
) {
return descriptions.stream().map(
description -> {
var wrappedDescription = new NodeDescription(
new NodeDescriptionParameters(node.getType()),
description
);
return new ReadOutput(
this.graphReader.readValues(node.getId(), wrappedDescription, contextGraph),
description
);
}
).toList();
}
private FilterOption<?> mapToFilterOption(List<ReadOutput> readOutputs) {
if (readOutputs.isEmpty()) {
throw new RuntimeException(
"Should not ever happen, because there should be at least default id node identifier."
);
}
if (readOutputs.size() == 1) {
return this.mapReadOutput(readOutputs.get(0));
}
return new AndFilterOption(
readOutputs.stream().map(this::mapReadOutput).collect(Collectors.toList())
);
}
@NotNull
private FilterOption<? extends FilterOptionParameters> mapReadOutput(ReadOutput readOutPut) {
if (readOutPut.getReadValues().size() == 1) {
return new EqualsFilterOption<>(
readOutPut.getReadGraphDescription(),
readOutPut.getReadValues().get(0)
);
}
return new AndFilterOption(
readOutPut.getReadValues().stream().map(
readValue -> new EqualsFilterOption<>(
readOutPut.getReadGraphDescription(),
readValue
)
).collect(Collectors.toList())
);
}
private static class ReadOutput {
private final List<Object> readValues;
private final PositiveGraphDescription readGraphDescription;
public ReadOutput(List<Object> readValues, PositiveGraphDescription readGraphDescription) {
this.readValues = readValues;
this.readGraphDescription = readGraphDescription;
}
public boolean isEmpty() {
return this.readValues.isEmpty();
}
public List<Object> getReadValues() {
return readValues;
}
public PositiveGraphDescription getReadGraphDescription() {
return readGraphDescription;
}
}
}
|
0 | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/nodeIdentificator | java-sources/ai/stapi/graph-operations/0.3.2/ai/stapi/graphoperations/synchronization/nodeIdentificator/exception/InvalidNodeIdentificator.java | package ai.stapi.graphoperations.synchronization.nodeIdentificator.exception;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.PositiveGraphDescription;
import ai.stapi.utils.Stringifier;
import java.util.List;
import java.util.stream.Collectors;
public class InvalidNodeIdentificator extends RuntimeException {
private InvalidNodeIdentificator(String becauseMessage) {
super("Node identificator was invalid, because " + becauseMessage);
}
public static InvalidNodeIdentificator becausePathToIdentifiactionValueDoesntStartWithEdgeOrAttributeDescription(
List<PositiveGraphDescription> invalidPaths
) {
return new InvalidNodeIdentificator(
String.format(
"path to identification value does not start with edge or attribute description. Invalid paths: %n%s",
invalidPaths.stream().map(Stringifier::convertToString).collect(Collectors.joining("\n"))
)
);
}
public static InvalidNodeIdentificator becausePathToIdentifiactionValueIsNotSinglePath(
List<PositiveGraphDescription> invalidPaths
) {
return new InvalidNodeIdentificator(
String.format(
"path to identification value is not single path. Invalid paths: %n%s",
invalidPaths.stream().map(Stringifier::convertToString).collect(Collectors.joining("\n"))
)
);
}
public static InvalidNodeIdentificator becausePathToIdentifiactionValueIsNotEndingWithUuidIdentityOrAttributeDescription(
List<PositiveGraphDescription> invalidPaths
) {
return new InvalidNodeIdentificator(
String.format(
"path to identification value is not ending with uuid identity or attribute description. " +
"Invalid paths: %n%s",
invalidPaths.stream().map(Stringifier::convertToString).collect(Collectors.joining("\n"))
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/infrastructure/AdHocAggregateDefinitionProvider.java | package ai.stapi.graphsystem.aggregatedefinition.infrastructure;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.aggregatedefinition.model.exceptions.CannotProvideAggregateDefinition;
import ai.stapi.schema.adHocLoaders.GenericAdHocModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import java.util.List;
import java.util.stream.Collectors;
public class AdHocAggregateDefinitionProvider implements AggregateDefinitionProvider {
private final GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader;
private final ScopeCacher scopeCacher;
private final OperationDefinitionProvider operationDefinitionProvider;
public AdHocAggregateDefinitionProvider(
GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader,
ScopeCacher scopeCacher,
OperationDefinitionProvider operationDefinitionProvider
) {
this.genericAdHocModelDefinitionsLoader = genericAdHocModelDefinitionsLoader;
this.scopeCacher = scopeCacher;
this.operationDefinitionProvider = operationDefinitionProvider;
}
@Override
public List<AggregateDefinitionDTO> provideAll() {
return this.getAggregateDefinitions();
}
@Override
public AggregateDefinitionDTO provide(
String aggregateType
) throws CannotProvideOperationDefinition {
return this.getAggregateDefinitions().stream()
.filter(aggregate -> aggregate.getName().equals(aggregateType))
.findFirst()
.orElseThrow(() -> CannotProvideAggregateDefinition.becauseItDoesNotExist(aggregateType));
}
private List<AggregateDefinitionDTO> getAggregateDefinitions() {
return this.scopeCacher.getCachedOrCompute(
AdHocAggregateDefinitionProvider.class,
this::load
);
}
private List<AggregateDefinitionDTO> load(ScopeOptions scopeOptions) {
var createAggregates = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
"CreateAggregateDefinition",
AggregateDefinitionDTO.class
).stream()
.toList();
var additionalCommandHandlers = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
"AddCommandOnAggregateDefinition",
AddCommandOnAggregateDefinitionDTO.class
).stream()
.toList();
this.ensureAdditionalCommandAreValid(scopeOptions, createAggregates, additionalCommandHandlers);
var groupedCommands = additionalCommandHandlers
.stream()
.collect(Collectors.groupingBy(AddCommandOnAggregateDefinitionDTO::getId));
var aggregatesWithAddedCommands = createAggregates.stream().map(
aggregate -> {
var addedCommands = groupedCommands.get(aggregate.getId());
if (addedCommands == null) {
return aggregate;
}
addedCommands.stream()
.map(AddCommandOnAggregateDefinitionDTO::getCommand)
.flatMap(List::stream)
.forEach(aggregate::addCommandHandlerDefinition);
return aggregate;
}
).toList();
var additionalModifications = this.genericAdHocModelDefinitionsLoader.load(
scopeOptions,
"AddModificationOnAggregateDefinitionCommandEventFactory",
AddModificationOnAggregateDefinitionDTO.class
).stream()
.toList();
this.ensureAdditionalModificationsAreValid(
scopeOptions,
aggregatesWithAddedCommands,
additionalModifications
);
var groupedModifications = additionalModifications
.stream()
.collect(Collectors.groupingBy(AddModificationOnAggregateDefinitionDTO::getId));
var aggregatesWithAddedModifications = createAggregates.stream().map(
aggregate -> {
var addedModifications = groupedModifications.get(aggregate.getId());
if (addedModifications == null) {
return aggregate;
}
addedModifications.forEach(addModification -> {
var foundEventFactory = aggregate.getCommand()
.stream()
.flatMap(command -> command.getEventFactory().stream())
.filter(
eventFactory -> eventFactory.getId().equals(
addModification.getEventFactoryId().split("/")[1]
)
)
.findFirst()
.get();
foundEventFactory.addModifications(addModification.getModification());
});
return aggregate;
}
).toList();
return aggregatesWithAddedModifications.stream().map(aggregate -> new AggregateDefinitionDTO(
aggregate.getId(),
aggregate.getName(),
aggregate.getDescription(),
aggregate.getCommand().stream().map(command -> new CommandHandlerDefinitionDTO(
this.operationDefinitionProvider.provide(command.getOperation().getId()),
command.getCreationalPolicy(),
command.getEventFactory()
)).toList(),
aggregate.getStructure()
)).toList();
}
private void ensureAdditionalCommandAreValid(
ScopeOptions scopeOptions,
List<AggregateDefinitionDTO> createAggregates,
List<AddCommandOnAggregateDefinitionDTO> additionalCommandHandlers
) {
var addCommandWithoutTarget = additionalCommandHandlers.stream()
.filter(map -> this.isNotContainedInFoundAggregates(createAggregates, map))
.toList();
if (!addCommandWithoutTarget.isEmpty()) {
throw new CannotProvideAggregateDefinition(
String.format(
"Cannot provide aggregate definitions for scope: %s with tags: %s.%n%s%n%s",
scopeOptions.getScopes(),
scopeOptions.getTags(),
"There were some AddCommandOnAggregateDefinition JSONs which eiter did "
+ "not have id specified or it was missing in found AggregateDefinitions.",
"Missing ids: " + addCommandWithoutTarget.stream()
.map(AddCommandOnAggregateDefinitionDTO::getId)
.toList()
)
);
}
}
private boolean isNotContainedInFoundAggregates(
List<AggregateDefinitionDTO> createAggregates,
AddCommandOnAggregateDefinitionDTO addCommand
) {
return addCommand.getId() == null || createAggregates.stream().noneMatch(
aggregate -> aggregate.getId().equals(addCommand.getId())
);
}
private void ensureAdditionalModificationsAreValid(
ScopeOptions scopeOptions,
List<AggregateDefinitionDTO> aggregates,
List<AddModificationOnAggregateDefinitionDTO> additionalModifications
) {
var addModificationWithoutTarget = additionalModifications.stream()
.filter(map -> !this.isModificationContainedInFoundAggregates(aggregates, map))
.toList();
if (!addModificationWithoutTarget.isEmpty()) {
throw new CannotProvideAggregateDefinition(
String.format(
"Cannot provide aggregate definitions for scope: %s with tags: %s.%n%s%n%s",
scopeOptions.getScopes(),
scopeOptions.getTags(),
"There were some AddModificationOnAggregateDefinition JSONs which eiter did "
+ "not have id specified or it was missing in found AggregateDefinitions.",
"Missing ids: " + addModificationWithoutTarget.stream()
.map(AddModificationOnAggregateDefinitionDTO::getId)
.toList()
)
);
}
}
private boolean isModificationContainedInFoundAggregates(
List<AggregateDefinitionDTO> aggregates,
AddModificationOnAggregateDefinitionDTO addModification
) {
if (addModification.getId() == null) {
return false;
}
if (addModification.getEventFactoryId() == null) {
return false;
}
var foundAggregate = aggregates.stream()
.filter(aggregate -> aggregate.getId().equals(addModification.getId()))
.findFirst();
if (foundAggregate.isEmpty()) {
return false;
}
return foundAggregate.get().getCommand().stream().anyMatch(
command -> command.getEventFactory().stream().anyMatch(
eventFactory -> eventFactory.getId().equals(
addModification.getEventFactoryId().split("/")[1]
)
)
);
}
private static class AddCommandOnAggregateDefinitionDTO {
private String id;
private List<CommandHandlerDefinitionDTO> command;
private AddCommandOnAggregateDefinitionDTO() {
}
public AddCommandOnAggregateDefinitionDTO(
String id,
List<CommandHandlerDefinitionDTO> command
) {
this.id = id;
this.command = command;
}
public String getId() {
return id;
}
public List<CommandHandlerDefinitionDTO> getCommand() {
return command;
}
}
private static class AddModificationOnAggregateDefinitionDTO {
private String id;
private String eventFactoryId;
private List<EventFactoryModification> modification;
private AddModificationOnAggregateDefinitionDTO() {
}
public AddModificationOnAggregateDefinitionDTO(
String id,
String eventFactoryId,
List<EventFactoryModification> modification
) {
this.id = id;
this.eventFactoryId = eventFactoryId;
this.modification = modification;
}
public String getId() {
return id;
}
public String getEventFactoryId() {
return eventFactoryId;
}
public List<EventFactoryModification> getModification() {
return modification;
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/infrastructure/DatabaseAggregateDefinitionProvider.java | package ai.stapi.graphsystem.aggregatedefinition.infrastructure;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.EdgeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.NodeDescriptionParameters;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.OutgoingEdgeDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.AttributeQueryDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.NodeQueryGraphDescription;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.query.OutgoingEdgeQueryDescription;
import ai.stapi.graphoperations.graphLoader.GraphLoader;
import ai.stapi.graphoperations.graphLoader.search.SearchQueryParameters;
import ai.stapi.graphoperations.graphLoader.search.paginationOption.OffsetPaginationOption;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.infrastructure.DatabaseOperationDefinitionProvider;
import java.util.ArrayList;
import java.util.List;
import org.jetbrains.annotations.NotNull;
import org.springframework.stereotype.Service;
public class DatabaseAggregateDefinitionProvider implements AggregateDefinitionProvider {
private final GraphLoader graphLoader;
private final DatabaseOperationDefinitionProvider databaseOperationDefinitionProvider;
private List<AggregateDefinitionDTO> cachedAggregates;
public DatabaseAggregateDefinitionProvider(
GraphLoader graphLoader,
DatabaseOperationDefinitionProvider databaseOperationDefinitionProvider
) {
this.graphLoader = graphLoader;
this.databaseOperationDefinitionProvider = databaseOperationDefinitionProvider;
this.cachedAggregates = new ArrayList<>();
}
@Override
public List<AggregateDefinitionDTO> provideAll() {
this.cacheOperations();
return this.cachedAggregates;
}
@Override
public AggregateDefinitionDTO provide(
String operationId
) throws CannotProvideOperationDefinition {
this.cacheOperations();
return this.cachedAggregates.stream()
.filter(operation -> operation.getId().equals(operationId))
.findFirst()
.orElseThrow(() -> new CannotProvideOperationDefinition(operationId));
}
private void cacheOperations() {
if (this.cachedAggregates.isEmpty()) {
this.cachedAggregates = this.graphLoader.find(
this.getAggregateGraphDescription(),
AggregateDefinitionDTO.class
).getData();
}
}
private NodeQueryGraphDescription getAggregateGraphDescription() {
return new NodeQueryGraphDescription(
new NodeDescriptionParameters("AggregateDefinition"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 50000))
.build(),
new UuidIdentityDescription(),
new AttributeQueryDescription("name"),
new AttributeQueryDescription("description"),
new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters("command"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
this.getCommandHandlerGraphDescription()
),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("structure"),
new NodeDescription(
new NodeDescriptionParameters("StructureDefinition"),
new UuidIdentityDescription()
)
)
);
}
@NotNull
private NodeDescription getCommandHandlerGraphDescription() {
return new NodeDescription(
new NodeDescriptionParameters("CommandHandlerDefinition"),
new AttributeQueryDescription("creationalPolicy"),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("operation"),
this.databaseOperationDefinitionProvider.getOperationGraphDescription()
),
new OutgoingEdgeQueryDescription(
new EdgeDescriptionParameters("eventFactory"),
SearchQueryParameters.builder()
.setPaginationOption(new OffsetPaginationOption(0, 300))
.build(),
this.getEventFactoryGraphDescription()
)
);
}
@NotNull
private NodeDescription getEventFactoryGraphDescription() {
return new NodeDescription(
"CommandHandlerDefinitionEventFactory",
new UuidIdentityDescription(),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("event"),
this.getEventMessageGraphDescription()
),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("modification"),
new NodeDescription(
"CommandHandlerDefinitionEventFactoryModification",
new AttributeQueryDescription("kind"),
new AttributeQueryDescription("modificationPath"),
new AttributeQueryDescription("inputValueParameterName"),
new AttributeQueryDescription("destinationIndexParameterName")
)
)
);
}
@NotNull
private NodeDescription getEventMessageGraphDescription() {
return new NodeDescription(
new NodeDescriptionParameters("EventMessageDefinition"),
new AttributeQueryDescription("name"),
new AttributeQueryDescription("description"),
new OutgoingEdgeDescription(
new EdgeDescriptionParameters("type"),
new NodeDescription(
new NodeDescriptionParameters("StructureDefinition")
),
new UuidIdentityDescription()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/infrastructure/NullAggregateDefinitionProvider.java | package ai.stapi.graphsystem.aggregatedefinition.infrastructure;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.exceptions.CannotProvideAggregateDefinition;
import java.util.List;
import org.springframework.context.annotation.Primary;
@Primary
public class NullAggregateDefinitionProvider implements AggregateDefinitionProvider {
@Override
public List<AggregateDefinitionDTO> provideAll() {
return List.of();
}
@Override
public AggregateDefinitionDTO provide(String aggregateType)
throws CannotProvideAggregateDefinition {
throw CannotProvideAggregateDefinition.becauseItDoesNotExist(aggregateType);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/infrastructure/OnDemandAggregateDefinitionProvider.java | package ai.stapi.graphsystem.aggregatedefinition.infrastructure;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO;
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.exceptions.CannotProvideAggregateDefinition;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.AddItemOnResourceOperationsMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.CreationalResourceOperationMapper;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import java.util.List;
public class OnDemandAggregateDefinitionProvider implements AggregateDefinitionProvider {
private final StructureSchemaProvider structureSchemaProvider;
private final ResourceAggregateDefinitionMapper aggregateMapper;
private final CreationalResourceOperationMapper createOperationMapper;
private final AddItemOnResourceOperationsMapper addItemOperationsMapper;
private final CreatedOperationEventFactoriesMapper createdEventFactoryMapper;
private final ItemAddedOperationEventFactoriesMapper itemAddedOperationEventFactoryMapper;
private final ScopeCacher scopeCacher;
public OnDemandAggregateDefinitionProvider(
StructureSchemaProvider structureSchemaProvider,
ResourceAggregateDefinitionMapper aggregateMapper,
CreationalResourceOperationMapper createOperationMapper,
AddItemOnResourceOperationsMapper addItemOperationsMapper,
CreatedOperationEventFactoriesMapper createdEventFactoryMapper,
ItemAddedOperationEventFactoriesMapper itemAddedOperationEventFactoryMapper,
ScopeCacher scopeCacher
) {
this.structureSchemaProvider = structureSchemaProvider;
this.aggregateMapper = aggregateMapper;
this.createOperationMapper = createOperationMapper;
this.addItemOperationsMapper = addItemOperationsMapper;
this.createdEventFactoryMapper = createdEventFactoryMapper;
this.itemAddedOperationEventFactoryMapper = itemAddedOperationEventFactoryMapper;
this.scopeCacher = scopeCacher;
}
@Override
public List<AggregateDefinitionDTO> provideAll() {
return this.getAggregates().stream().toList();
}
@Override
public AggregateDefinitionDTO provide(
String aggregateType
) throws CannotProvideAggregateDefinition {
return this.getAggregates().stream()
.filter(resource -> resource.getName().equals(aggregateType))
.findFirst()
.orElseThrow(() -> CannotProvideAggregateDefinition.becauseItDoesNotExist(aggregateType));
}
@Override
public boolean containsAggregateForOperation(String operationDefinitionId) {
var cached = this.scopeCacher.<List<AggregateDefinitionDTO>>getCached(
OnDemandAggregateDefinitionProvider.class
);
if (cached == null) {
return false;
}
return cached.stream().anyMatch(
aggregate -> aggregate.containsOperation(operationDefinitionId)
);
}
private List<AggregateDefinitionDTO> getAggregates() {
return this.scopeCacher.getCachedOrCompute(
OnDemandAggregateDefinitionProvider.class,
this::createAggregates
);
}
private List<AggregateDefinitionDTO> createAggregates(ScopeOptions scopeOptions) {
return this.structureSchemaProvider.provideSchema()
.getStructureTypes()
.values()
.stream()
.filter(ResourceStructureType.class::isInstance)
.map(ResourceStructureType.class::cast)
.map(this::createAggregateDefinition)
.toList();
}
private AggregateDefinitionDTO createAggregateDefinition(
ResourceStructureType resourceStructureType
) {
var aggregateDefinition = this.aggregateMapper.map(resourceStructureType);
var addItemCommandHandlers = this.createAddItemCommandHandlers(
resourceStructureType
);
addItemCommandHandlers.forEach(aggregateDefinition::addCommandHandlerDefinition);
if (!resourceStructureType.isAbstract()) {
aggregateDefinition.addCommandHandlerDefinition(
this.createCreateCommandHandler(resourceStructureType)
);
}
return aggregateDefinition;
}
private List<CommandHandlerDefinitionDTO> createAddItemCommandHandlers(
ResourceStructureType resourceStructureType
) {
return this.addItemOperationsMapper.map(resourceStructureType).getOperations()
.stream()
.map(this::createAddItemCommandHandler)
.toList();
}
private CommandHandlerDefinitionDTO createAddItemCommandHandler(
OperationDefinitionDTO operationDefinition
) {
var itemAddedFactories = this.itemAddedOperationEventFactoryMapper.map(operationDefinition);
return new CommandHandlerDefinitionDTO(
operationDefinition,
CommandHandlerDefinitionDTO.CreationPolicy.NEVER,
itemAddedFactories
);
}
private CommandHandlerDefinitionDTO createCreateCommandHandler(
ResourceStructureType resourceStructureType
) {
var operationDefinition = this.createOperationMapper.map(resourceStructureType)
.getOperations()
.get(0);
var eventFactories = this.createdEventFactoryMapper.map(operationDefinition);
return new CommandHandlerDefinitionDTO(
operationDefinition,
CommandHandlerDefinitionDTO.CreationPolicy.IF_MISSING,
eventFactories
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/AggregateDefinitionDTO.java | package ai.stapi.graphsystem.aggregatedefinition.model;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.ArrayList;
import java.util.List;
public class AggregateDefinitionDTO {
private String id;
private String name;
private String description;
private List<CommandHandlerDefinitionDTO> command;
private StructureDefinitionId structure;
protected AggregateDefinitionDTO() {
}
public AggregateDefinitionDTO(
String id,
String name,
String description,
List<CommandHandlerDefinitionDTO> command,
StructureDefinitionId structure
) {
this.id = id;
this.name = name;
this.description = description;
this.command = command;
this.structure = structure;
}
public AggregateDefinitionDTO(
String id,
String name,
String description,
StructureDefinitionId structure
) {
this(id, name, description, new ArrayList<>(), structure);
}
public AggregateDefinitionDTO addCommandHandlerDefinition(
CommandHandlerDefinitionDTO commandHandlerDefinition
) {
this.command.add(commandHandlerDefinition);
return this;
}
@JsonIgnore
public boolean containsOperation(String operationId) {
return this.command.stream().anyMatch(
someCommand -> someCommand.getOperation().getId().equals(operationId)
);
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public List<CommandHandlerDefinitionDTO> getCommand() {
return command;
}
public StructureDefinitionId getStructure() {
return structure;
}
} |
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/AggregateDefinitionProvider.java | package ai.stapi.graphsystem.aggregatedefinition.model;
import ai.stapi.graphsystem.aggregatedefinition.model.exceptions.CannotProvideAggregateDefinition;
import java.util.List;
public interface AggregateDefinitionProvider {
List<AggregateDefinitionDTO> provideAll();
AggregateDefinitionDTO provide(String aggregateType) throws CannotProvideAggregateDefinition;
default AggregateDefinitionDTO getAggregateForOperation(
String operationDefinitionId
) throws CannotProvideAggregateDefinition {
var foundAggregates = this.provideAll().stream()
.filter(aggregate -> aggregate.containsOperation(operationDefinitionId))
.toList();
if (foundAggregates.isEmpty()) {
throw CannotProvideAggregateDefinition.becauseThereIsNoCommandHandlerForOperation(
operationDefinitionId
);
}
return foundAggregates.get(0);
}
default boolean containsAggregateForOperation(String operationDefinitionId) {
return this.provideAll().stream().anyMatch(
aggregate -> aggregate.containsOperation(operationDefinitionId)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/CommandHandlerDefinitionDTO.java | package ai.stapi.graphsystem.aggregatedefinition.model;
import ai.stapi.graphsystem.eventdefinition.EventMessageDefinitionData;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import java.util.List;
import java.util.UUID;
import org.jetbrains.annotations.Nullable;
public class CommandHandlerDefinitionDTO {
private OperationDefinitionDTO operation;
private String creationalPolicy;
private List<EventFactory> eventFactory;
private CommandHandlerDefinitionDTO() {
}
public CommandHandlerDefinitionDTO(
OperationDefinitionDTO operation,
String creationalPolicy,
List<EventFactory> eventFactory
) {
this.operation = operation;
this.creationalPolicy = creationalPolicy;
this.eventFactory = eventFactory;
}
public OperationDefinitionDTO getOperation() {
return operation;
}
public String getCreationalPolicy() {
return creationalPolicy;
}
public List<EventFactory> getEventFactory() {
return eventFactory;
}
public static class EventFactory {
private String id;
private EventMessageDefinitionData event;
private List<EventFactoryModification> modification;
protected EventFactory() {
}
public EventFactory(
String id,
EventMessageDefinitionData event,
List<EventFactoryModification> modification
) {
this.id = id;
this.event = event;
this.modification = modification;
}
public EventFactory(
EventMessageDefinitionData event,
List<EventFactoryModification> modification
) {
this(
UUID.randomUUID().toString(),
event,
modification
);
}
public void addModification(EventFactoryModification modification) {
this.getModification().add(modification);
}
public void addModifications(List<EventFactoryModification> modifications) {
this.getModification().addAll(modifications);
}
public EventMessageDefinitionData getEvent() {
return event;
}
public List<EventFactoryModification> getModification() {
return modification;
}
public String getId() {
return id;
}
}
public static class CreationPolicy {
public static final String ALWAYS = "always";
public static final String NEVER = "never";
public static final String IF_MISSING = "if_missing";
private CreationPolicy() {
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/EventFactoryModification.java | package ai.stapi.graphsystem.aggregatedefinition.model;
import org.jetbrains.annotations.Nullable;
public class EventFactoryModification {
public static final String ADD = "add";
public static final String UPSERT = "upsert";
public static final String REMOVE = "remove";
public static final String INSERT = "insert";
public static final String MOVE = "move";
private String kind;
private String modificationPath;
@Nullable
private String startIdParameterName;
@Nullable
private String inputValueParameterName;
@Nullable
private String destinationIndexParameterName;
private EventFactoryModification() {
}
private EventFactoryModification(
String kind,
String modificationPath,
@Nullable String startIdParameterName,
@Nullable String inputValueParameterName,
@Nullable String destinationIndexParameterName
) {
this.kind = kind;
this.modificationPath = modificationPath;
this.startIdParameterName = startIdParameterName;
this.inputValueParameterName = inputValueParameterName;
this.destinationIndexParameterName = destinationIndexParameterName;
}
public static EventFactoryModification add(
String modificationPath,
@Nullable String startIdParameterName,
@Nullable String inputValueParameterName
) {
return new EventFactoryModification(
ADD,
modificationPath,
startIdParameterName,
inputValueParameterName,
null
);
}
public static EventFactoryModification upsert(
String modificationPath,
@Nullable String startIdParameterName,
@Nullable String inputValueParameterName
) {
return new EventFactoryModification(
UPSERT,
modificationPath,
startIdParameterName,
inputValueParameterName,
null
);
}
public static EventFactoryModification remove(
String modificationPath,
@Nullable String startIdParameterName,
@Nullable String inputValueParameterName
) {
return new EventFactoryModification(
REMOVE,
modificationPath,
startIdParameterName,
inputValueParameterName,
null
);
}
public static EventFactoryModification insert(
String modificationPath,
@Nullable String startIdParameterName,
@Nullable String inputValueParameterName,
@Nullable String destinationIndexParameterName
) {
return new EventFactoryModification(
INSERT,
modificationPath,
startIdParameterName,
inputValueParameterName,
destinationIndexParameterName
);
}
public static EventFactoryModification move(
String modificationPath,
@Nullable String startIdParameterName,
@Nullable String inputValueParameterName,
@Nullable String destinationIndexParameterName
) {
return new EventFactoryModification(
MOVE,
modificationPath,
startIdParameterName,
inputValueParameterName,
destinationIndexParameterName
);
}
public String getKind() {
return kind;
}
public String getModificationPath() {
return modificationPath;
}
public String getStartIdParameterName() {
return startIdParameterName;
}
@Nullable
public String getInputValueParameterName() {
return inputValueParameterName;
}
@Nullable
public String getDestinationIndexParameterName() {
return destinationIndexParameterName;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/ResourceAggregateDefinitionMapper.java | package ai.stapi.graphsystem.aggregatedefinition.model;
import ai.stapi.schema.structureSchema.ResourceStructureType;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
public class ResourceAggregateDefinitionMapper {
public AggregateDefinitionDTO map(ResourceStructureType resourceStructureType) {
var resourceName = resourceStructureType.getDefinitionType();
return new AggregateDefinitionDTO(
String.format("%sAggregate", resourceName),
resourceName,
resourceStructureType.getDescription(),
new StructureDefinitionId(resourceName)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/eventFactory/CreatedOperationEventFactoriesMapper.java | package ai.stapi.graphsystem.aggregatedefinition.model.eventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.EventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.eventdefinition.EventMessageDefinitionData;
import ai.stapi.graphsystem.operationdefinition.model.FieldDefinitionWithSource;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.OperationDefinitionParameters;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
public class CreatedOperationEventFactoriesMapper implements OperationEventFactoriesMapper {
private final OperationDefinitionStructureTypeMapper mapper;
private final AggregateDefinitionProvider aggregateDefinitionProvider;
public CreatedOperationEventFactoriesMapper(
OperationDefinitionStructureTypeMapper mapper,
AggregateDefinitionProvider aggregateDefinitionProvider
) {
this.mapper = mapper;
this.aggregateDefinitionProvider = aggregateDefinitionProvider;
}
@Override
public List<EventFactory> map(OperationDefinitionDTO operationDefinition) {
var resourceName = operationDefinition.getResource().get(0);
var createdEventId = this.createCreatedEventId(resourceName);
var createdEventName = this.createCreatedEventName(resourceName);
var fakedStructure = this.mapper.map(operationDefinition);
var eventFactory = this.getEventFactory(operationDefinition.getId());
return List.of(
new EventFactory(
eventFactory.isPresent() ? eventFactory.get().getId() : UUID.randomUUID().toString(),
new EventMessageDefinitionData(
createdEventId,
createdEventName,
new StructureDefinitionId(resourceName),
"Generated Event for newly created " + resourceName + "."
),
fakedStructure.getAllFields().values().stream()
.map(param -> this.createModification(
param.getName(),
param.getName()
)).toList()
)
);
}
@Override
public List<EventFactoryModificationResult> mapParameters(
OperationDefinitionParameters operationDefinitionParameters
) {
var operationId = operationDefinitionParameters.getOperationId();
var eventFactory = this.getEventFactory(operationId);
var fakedStructure = this.mapper.map(
OperationDefinitionDTO.bareBone(operationId, operationDefinitionParameters.getParameters())
);
return List.of(
new EventFactoryModificationResult(
eventFactory.isPresent() ? eventFactory.get().getId() : UUID.randomUUID().toString(),
fakedStructure.getAllFields().values().stream()
.map(FieldDefinitionWithSource.class::cast)
.map(param -> this.createModification(
param.getName(),
param.getName()
)).toList()
)
);
}
private Optional<EventFactory> getEventFactory(String operationId) {
if (!this.aggregateDefinitionProvider.containsAggregateForOperation(operationId)) {
return Optional.empty();
}
var aggregate = this.aggregateDefinitionProvider.getAggregateForOperation(
operationId
);
var commandHandler = aggregate.getCommand().stream()
.filter(command -> command.getOperation().getId().equals(operationId))
.findFirst();
if (commandHandler.isPresent()) {
var eventFactories = commandHandler.get().getEventFactory();
if (!eventFactories.isEmpty()) {
return Optional.of(eventFactories.get(0));
}
}
return Optional.empty();
}
private EventFactoryModification createModification(
String modificationPath,
String parameterName
) {
return EventFactoryModification.add(
modificationPath,
null,
parameterName
);
}
private String createCreatedEventId(String resourceName) {
return resourceName + "Created";
}
private String createCreatedEventName(String resourceName) {
return resourceName + " Created";
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/eventFactory/EventFactoryModificationResult.java | package ai.stapi.graphsystem.aggregatedefinition.model.eventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import java.util.List;
public class EventFactoryModificationResult {
private final String eventFactoryId;
private final List<EventFactoryModification> eventFactoryModifications;
public EventFactoryModificationResult(
String eventFactoryId,
List<EventFactoryModification> eventFactoryModifications
) {
this.eventFactoryId = eventFactoryId;
this.eventFactoryModifications = eventFactoryModifications;
}
public String getEventFactoryId() {
return eventFactoryId;
}
public List<EventFactoryModification> getEventFactoryModifications() {
return eventFactoryModifications;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/eventFactory/ItemAddedOperationEventFactoriesMapper.java | package ai.stapi.graphsystem.aggregatedefinition.model.eventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.EventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.eventdefinition.EventMessageDefinitionData;
import ai.stapi.graphsystem.operationdefinition.model.FieldDefinitionWithSource;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.OperationDefinitionParameters;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class ItemAddedOperationEventFactoriesMapper implements OperationEventFactoriesMapper {
private final OperationDefinitionStructureTypeMapper mapper;
public ItemAddedOperationEventFactoriesMapper(OperationDefinitionStructureTypeMapper mapper) {
this.mapper = mapper;
}
@Override
public List<EventFactory> map(OperationDefinitionDTO operationDefinition) {
var resourceName = operationDefinition.getResource().get(0);
var itemAddedEventId = this.createItemAddedEventId(operationDefinition.getId());
var itemAddedEventName = this.createItemAddedEventName(operationDefinition.getId());
var fakedStructure = this.mapper.map(operationDefinition);
var idParameter = fakedStructure.getAllFields().values().stream()
.map(FieldDefinitionWithSource.class::cast)
.filter(field -> field.getLastSourcePath().equals("id"))
.findFirst();
return List.of(
new EventFactory(
new EventMessageDefinitionData(
itemAddedEventId,
itemAddedEventName,
new StructureDefinitionId(resourceName),
"Generated Event for adding on " + resourceName + "."
),
fakedStructure.getAllFields().values().stream()
.map(FieldDefinitionWithSource.class::cast)
.filter(field -> !field.getLastSourcePath().equals("id"))
.map(fieldDefinition -> this.createModification(
this.createModificationPath(fieldDefinition, idParameter),
idParameter.map(FieldDefinition::getName).orElse(null),
fieldDefinition.getName()
)).toList()
)
);
}
@Override
public List<EventFactoryModificationResult> mapParameters(
OperationDefinitionParameters operationDefinitionParameters
) {
return List.of();
}
private String createModificationPath(
FieldDefinitionWithSource fieldDefinition,
Optional<FieldDefinitionWithSource> idParameter
) {
var source = fieldDefinition.getSource().split("\\.");
var startIndex = idParameter
.map(fieldDefinitionWithSource -> fieldDefinitionWithSource.getSourceLength() - 1)
.orElse(1);
return String.join(".", Arrays.copyOfRange(source, startIndex, source.length));
}
private EventFactoryModification createModification(
String sourcePath,
String startIdParameterName,
String parameterName
) {
return EventFactoryModification.add(
sourcePath,
startIdParameterName,
parameterName
);
}
private String createItemAddedEventId(String operationName) {
var prefix = "Add";
var suffix = "Added";
// Check if input string starts with "Add"
if (operationName.startsWith(prefix)) {
// If so, remove the "Add" prefix and append the "Added" suffix
return operationName.substring(prefix.length()) + suffix;
} else {
// If not, simply append the "Added" suffix to the input string
return operationName + suffix;
}
}
private String createItemAddedEventName(String operationName) {
var prefix = "Add";
var suffix = "Added";
String substring = operationName;
// Check if input string starts with "Add"
if (operationName.startsWith(prefix)) {
// If so, remove the "Add" prefix and append the "Added" suffix
substring = operationName.substring(prefix.length());
}
var parts = substring.split("On");
return String.format(
"%s %s",
String.join(" on ", parts),
suffix
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/eventFactory/OperationEventFactoriesMapper.java | package ai.stapi.graphsystem.aggregatedefinition.model.eventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.EventFactory;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.OperationDefinitionParameters;
import java.util.List;
public interface OperationEventFactoriesMapper {
List<EventFactory> map(OperationDefinitionDTO operationDefinition);
List<EventFactoryModificationResult> mapParameters(
OperationDefinitionParameters operationDefinitionParameters
);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/eventFactory/UpdatedOperationEventFactoriesMapper.java | package ai.stapi.graphsystem.aggregatedefinition.model.eventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.EventFactory;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.eventdefinition.EventMessageDefinitionData;
import ai.stapi.graphsystem.operationdefinition.model.FieldDefinitionWithSource;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.graphsystem.operationdefinition.model.resourceStructureTypeOperationsMapper.OperationDefinitionParameters;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
public class UpdatedOperationEventFactoriesMapper implements OperationEventFactoriesMapper {
private final OperationDefinitionStructureTypeMapper mapper;
private final AggregateDefinitionProvider aggregateDefinitionProvider;
public UpdatedOperationEventFactoriesMapper(
OperationDefinitionStructureTypeMapper mapper,
AggregateDefinitionProvider aggregateDefinitionProvider
) {
this.mapper = mapper;
this.aggregateDefinitionProvider = aggregateDefinitionProvider;
}
@Override
public List<EventFactory> map(OperationDefinitionDTO operationDefinition) {
var resourceName = operationDefinition.getResource().get(0);
var createdEventId = this.createUpdatedEventId(resourceName);
var createdEventName = this.createUpdatedEventName(resourceName);
var fakedStructure = this.mapper.map(operationDefinition);
var eventFactory = this.getEventFactory(operationDefinition.getId());
return List.of(
new EventFactory(
eventFactory.isPresent() ? eventFactory.get().getId() : UUID.randomUUID().toString(),
new EventMessageDefinitionData(
createdEventId,
createdEventName,
new StructureDefinitionId(resourceName),
"Generated Event for updated " + resourceName + "."
),
fakedStructure.getAllFields().values().stream()
.map(param -> this.createModification(
param.getName(),
param.getName()
)).toList()
)
);
}
@Override
public List<EventFactoryModificationResult> mapParameters(
OperationDefinitionParameters operationDefinitionParameters
) {
var operationId = operationDefinitionParameters.getOperationId();
var eventFactory = this.getEventFactory(operationId);
var fakedStructure = this.mapper.map(
OperationDefinitionDTO.bareBone(operationId, operationDefinitionParameters.getParameters())
);
return List.of(
new EventFactoryModificationResult(
eventFactory.isPresent() ? eventFactory.get().getId() : UUID.randomUUID().toString(),
fakedStructure.getAllFields().values().stream()
.map(FieldDefinitionWithSource.class::cast)
.map(param -> this.createModification(
param.getName(),
param.getName()
)).toList()
)
);
}
private Optional<EventFactory> getEventFactory(String operationId) {
if (!this.aggregateDefinitionProvider.containsAggregateForOperation(operationId)) {
return Optional.empty();
}
var aggregate = this.aggregateDefinitionProvider.getAggregateForOperation(
operationId
);
var commandHandler = aggregate.getCommand().stream()
.filter(command -> command.getOperation().getId().equals(operationId))
.findFirst();
if (commandHandler.isPresent()) {
var eventFactories = commandHandler.get().getEventFactory();
if (!eventFactories.isEmpty()) {
return Optional.of(eventFactories.get(0));
}
}
return Optional.empty();
}
private EventFactoryModification createModification(
String modificationPath,
String parameterName
) {
return EventFactoryModification.upsert(
modificationPath,
null,
parameterName
);
}
private String createUpdatedEventId(String resourceName) {
return resourceName + "Updated";
}
private String createUpdatedEventName(String resourceName) {
return resourceName + " Updated";
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregatedefinition/model/exceptions/CannotProvideAggregateDefinition.java | package ai.stapi.graphsystem.aggregatedefinition.model.exceptions;
public class CannotProvideAggregateDefinition extends RuntimeException {
public CannotProvideAggregateDefinition(String message) {
super(message);
}
private CannotProvideAggregateDefinition(
String aggregateName,
String becauseMessage,
Throwable cause
) {
super(
String.format(
"Cannot Provide Aggregate Definition for: '%s', because %s%nCause: %s",
aggregateName,
becauseMessage,
cause.getMessage()
)
);
}
public static CannotProvideAggregateDefinition becauseItDoesNotExist(String aggregateName) {
return new CannotProvideAggregateDefinition(
String.format(
"Cannot Provide Aggregate Definition for: '%s', because it does not exists.",
aggregateName
)
);
}
public static CannotProvideAggregateDefinition becauseRelatedOperationDefinitionNotFound(
String aggregateName,
String operationName,
Throwable cause
) {
return new CannotProvideAggregateDefinition(
aggregateName,
String.format("related operation with name '%s' was not found.", operationName),
cause
);
}
public static CannotProvideAggregateDefinition becauseRelatedStructureSchemaNotFound(
String aggregateName,
Throwable cause
) {
return new CannotProvideAggregateDefinition(
aggregateName,
"related Structure Schema was not found.",
cause
);
}
public static CannotProvideAggregateDefinition becauseThereIsNoCommandHandlerForOperation(
String operationDefinitionId
) {
return new CannotProvideAggregateDefinition(
String.format(
"Cannot Provide Aggregate Definition for: '%s', because there is no command handler for this operation.",
operationDefinitionId
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/AbstractAggregateGraphStateModificator.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import java.util.HashMap;
import java.util.Map;
import org.jetbrains.annotations.NotNull;
public abstract class AbstractAggregateGraphStateModificator implements AggregateGraphStateModificator {
protected final GenericObjectGraphMapper objectGraphMapper;
protected final EventFactoryModificationTraverser eventFactoryModificationTraverser;
protected final EventModificatorOgmProvider eventModificatorOgmProvider;
public AbstractAggregateGraphStateModificator(
GenericObjectGraphMapper objectGraphMapper,
EventFactoryModificationTraverser eventFactoryModificationTraverser,
EventModificatorOgmProvider eventModificatorOgmProvider
) {
this.objectGraphMapper = objectGraphMapper;
this.eventFactoryModificationTraverser = eventFactoryModificationTraverser;
this.eventModificatorOgmProvider = eventModificatorOgmProvider;
}
@NotNull
protected Map<String, Object> getMappedObject(
Object inputValue,
TraversableNode modifiedNode,
String fieldName
) {
return new HashMap<>(Map.of(
"id", modifiedNode.getId().getId(),
fieldName, inputValue
));
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/AddAggregateGraphStateModificator.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graph.Graph;
import ai.stapi.graph.graphelements.Node;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.GraphMappingResult;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.DynamicOgmProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.aggregategraphstatemodifier.exceptions.CannotAddToAggregateState;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
public class AddAggregateGraphStateModificator extends AbstractAggregateGraphStateModificator {
public AddAggregateGraphStateModificator(
GenericObjectGraphMapper objectGraphMapper,
EventFactoryModificationTraverser eventFactoryModificationTraverser,
EventModificatorOgmProvider eventModificatorOgmProvider
) {
super(objectGraphMapper, eventFactoryModificationTraverser, eventModificatorOgmProvider);
}
@Override
public GraphMappingResult modify(
String aggregateType,
Graph currentAggregateState,
DynamicCommand command,
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var inputValueParameterName = modificationDefinition.getInputValueParameterName();
if (inputValueParameterName == null) {
throw CannotAddToAggregateState.becauseModificationDefinitionDoesNotHaveInputValueParameterNameSpecified(
modificationDefinition,
operationStructureType
);
}
var inputValue = command.getData().get(inputValueParameterName);
if (inputValue == null) {
return new GraphMappingResult(
new Graph(new Node(command.getTargetIdentifier(), aggregateType)),
List.of()
);
}
var aggregateRepo = currentAggregateState.traversable();
var traversingStartNode = this.eventFactoryModificationTraverser.getTraversingStartNode(
aggregateType,
command.getTargetIdentifier(),
command.getData(),
modificationDefinition,
operationStructureType,
aggregateRepo
);
var modificationPath = modificationDefinition.getModificationPath();
var splitPath = modificationPath.split("\\.");
var modifiedNode = this.eventFactoryModificationTraverser.traverseToModifiedNode(
traversingStartNode,
splitPath,
operationStructureType,
modificationDefinition
);
var inputValueSchema = operationStructureType.getField(inputValueParameterName);
var fieldName = splitPath[splitPath.length - 1];
if (inputValueSchema.getFloatMax() < 2) {
if (!modifiedNode.getEdges(fieldName).isEmpty()) {
throw CannotAddToAggregateState.becauseThereAlreadyIsSuchLeafComplexType(
modificationDefinition,
operationStructureType,
modifiedNode
);
}
if (modifiedNode.hasAttribute(fieldName)) {
throw CannotAddToAggregateState.becauseThereAlreadyIsSuchLeafAttribute(
modificationDefinition,
operationStructureType,
modifiedNode
);
}
}
var objectOgm = this.eventModificatorOgmProvider.getOgm(modifiedNode, inputValueSchema, fieldName);
var fakedObject = this.getMappedObject(inputValue, modifiedNode, fieldName);
return this.objectGraphMapper.mapToGraph(
objectOgm,
fakedObject,
missingFieldResolvingStrategy
);
}
@Override
public boolean supports(EventFactoryModification modificationDefinition) {
return modificationDefinition.getKind().equals(EventFactoryModification.ADD);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/AggregateGraphStateModificator.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graph.Graph;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphoperations.objectGraphMapper.model.GraphMappingResult;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.schema.structureSchema.ComplexStructureType;
public interface AggregateGraphStateModificator {
GraphMappingResult modify(
String aggregateType,
Graph currentAggregateState,
DynamicCommand command,
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
);
boolean supports(EventFactoryModification modificationDefinition);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/DynamicAggregateCommandProcessor.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO.EventFactory;
import ai.stapi.graphsystem.dynamiccommandprocessor.SpecificDynamicCommandProcessor;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphMapper.model.GraphMappingResult;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import java.util.List;
public class DynamicAggregateCommandProcessor implements SpecificDynamicCommandProcessor {
private final AggregateDefinitionProvider aggregateDefinitionProvider;
private final GenericAggregateGraphStateModificator genericAggregateGraphStateModificator;
public DynamicAggregateCommandProcessor(
AggregateDefinitionProvider aggregateDefinitionProvider,
GenericAggregateGraphStateModificator genericAggregateGraphStateModificator
) {
this.aggregateDefinitionProvider = aggregateDefinitionProvider;
this.genericAggregateGraphStateModificator = genericAggregateGraphStateModificator;
}
@Override
public List<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> processCommand(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var aggregateDefinition = this.aggregateDefinitionProvider.provideAll()
.stream()
.filter(
aggregateDefinitionDTO ->
aggregateDefinitionDTO.getCommand()
.stream()
.anyMatch(
commandHandlerDefinitionDTO ->
commandHandlerDefinitionDTO.getOperation().getId()
.equals(command.getSerializationType())
)
).findFirst()
.orElseThrow();
var commandHandlerDefinition = aggregateDefinition.getCommand()
.stream()
.filter(
commandHandlerDefinitionDTO -> commandHandlerDefinitionDTO.getOperation()
.getId()
.equals(command.getSerializationType())
).findFirst()
.orElseThrow();
var operationDefinition = commandHandlerDefinition.getOperation();
return commandHandlerDefinition.getEventFactory()
.stream()
.map(eventFactory -> this.createEvent(
command,
currentAggregateState,
aggregateDefinition.getStructure().getId(),
eventFactory,
operationDefinition,
missingFieldResolvingStrategy
)).toList();
}
private DynamicGraphUpdatedEvent createEvent(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState,
String aggregateType,
EventFactory eventFactory,
OperationDefinitionDTO operationDefinition,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var graphMappingResult = eventFactory.getModification().stream()
.map(modification -> this.genericAggregateGraphStateModificator.modify(
aggregateType,
currentAggregateState,
(DynamicCommand) command,
modification,
operationDefinition,
missingFieldResolvingStrategy
)).reduce(GraphMappingResult::merge)
.orElse(new GraphMappingResult(
new Graph(),
List.of()
));
return new DynamicGraphUpdatedEvent(
eventFactory.getEvent().getId(),
command.getTargetIdentifier(),
graphMappingResult.getGraph(),
graphMappingResult.getElementForRemoval()
);
}
@Override
public boolean supports(AbstractCommand<? extends UniqueIdentifier> command) {
return this.aggregateDefinitionProvider.provideAll()
.stream()
.anyMatch(
aggregateDefinitionDTO -> aggregateDefinitionDTO.getCommand()
.stream()
.anyMatch(commandHandlerDefinitionDTO -> commandHandlerDefinitionDTO.getOperation()
.getId().equals(command.getSerializationType()))
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/EventFactoryModificationTraverser.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graph.exceptions.NodeNotFound;
import ai.stapi.graph.inMemoryGraph.InMemoryGraphRepository;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.aggregategraphstatemodifier.exceptions.CannotModifyAggregateState;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class EventFactoryModificationTraverser {
public TraversableNode getTraversingStartNode(
String aggregateType,
UniqueIdentifier aggregateId,
Map<String, Object> possibleStartIds,
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
InMemoryGraphRepository aggregateRepo
) {
var startIdParameterName = modificationDefinition.getStartIdParameterName();
if (startIdParameterName == null) {
if (aggregateRepo.nodeExists(aggregateId, aggregateType)) {
return aggregateRepo.loadNode(aggregateId, aggregateType);
} else {
return new TraversableNode(aggregateId, aggregateType);
}
} else {
var startIdValue = possibleStartIds.get(startIdParameterName);
if (!(startIdValue instanceof String stringStartId)) {
throw CannotModifyAggregateState.becauseThereIsNoIdInCommandAtStartIdParameterName(
startIdParameterName,
modificationDefinition,
operationStructureType
);
}
if (!stringStartId.contains("/")) {
throw CannotModifyAggregateState.becauseStartIdIsNotOfCorrectFormat(
stringStartId,
startIdParameterName,
modificationDefinition,
operationStructureType
);
}
var splitId = stringStartId.split("/");
if (splitId.length != 2) {
throw CannotModifyAggregateState.becauseStartIdIsNotOfCorrectFormat(
stringStartId,
startIdParameterName,
modificationDefinition,
operationStructureType
);
}
try {
return aggregateRepo.loadNode(
new UniqueIdentifier(splitId[1]),
splitId[0]
);
} catch (NodeNotFound nodeNotFound) {
throw CannotModifyAggregateState.becauseThereIsNoNodeWithIdSpecifiedAtStartIdParameterName(
modificationDefinition,
operationStructureType,
new UniqueIdentifier(stringStartId),
startIdParameterName
);
}
}
}
public TraversableNode traverseToModifiedNode(
TraversableNode currentNode,
String[] pathToTraverse,
ComplexStructureType operationDefinition,
EventFactoryModification modificationDefinition,
List<String> alreadyTraversedPath
) {
if (pathToTraverse.length < 2) {
return currentNode;
}
var fieldName = pathToTraverse[0];
var edges = currentNode.getEdges(fieldName);
var newAlreadyTraversedPath = new ArrayList<>(alreadyTraversedPath);
newAlreadyTraversedPath.add(fieldName);
if (edges.size() > 1) {
throw CannotModifyAggregateState.becauseThereAreEdgesOnPathEvenThoughtThereShouldBeMaxOne(
modificationDefinition,
operationDefinition,
String.join(".", newAlreadyTraversedPath)
);
}
if (edges.isEmpty()) {
throw CannotModifyAggregateState.becauseThereAreIsNodeEdgeOnPathEvenThoughtThereShouldBeOne(
modificationDefinition,
operationDefinition,
String.join(".", newAlreadyTraversedPath)
);
}
return this.traverseToModifiedNode(
edges.get(0).getNodeTo(),
Arrays.copyOfRange(pathToTraverse, 1, pathToTraverse.length),
operationDefinition,
modificationDefinition,
newAlreadyTraversedPath
);
}
public TraversableNode traverseToModifiedNode(
TraversableNode currentNode,
String[] pathToTraverse,
ComplexStructureType operationDefinition,
EventFactoryModification modificationDefinition
) {
return this.traverseToModifiedNode(
currentNode,
pathToTraverse,
operationDefinition,
modificationDefinition,
List.of()
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/EventModificatorOgmProvider.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphoperations.graphLanguage.graphDescription.graphDescriptionBuilder.GraphDescriptionBuilder;
import ai.stapi.graphoperations.graphLanguage.graphDescription.specific.positive.UuidIdentityDescription;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.GenericOGMBuilder;
import ai.stapi.graphoperations.objectGraphLanguage.objectGraphMappingBuilder.specific.ogm.ObjectGraphMappingBuilder;
import ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.DynamicOgmProvider;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import org.jetbrains.annotations.NotNull;
public class EventModificatorOgmProvider {
protected final StructureSchemaFinder structureSchemaFinder;
protected final DynamicOgmProvider dynamicOgmProvider;
public EventModificatorOgmProvider(
StructureSchemaFinder structureSchemaFinder,
DynamicOgmProvider dynamicOgmProvider
) {
this.structureSchemaFinder = structureSchemaFinder;
this.dynamicOgmProvider = dynamicOgmProvider;
}
@NotNull
public ObjectGraphMapping getOgm(
TraversableNode modifiedNode,
FieldDefinition inputValueSchema,
String fieldName
) {
var objectOgm = new ObjectGraphMappingBuilder().setGraphDescription(
new GraphDescriptionBuilder().addNodeDescription(modifiedNode.getType())
);
objectOgm
.addField("id")
.addLeafAsObjectFieldMapping()
.setGraphDescription(new UuidIdentityDescription());
var dataField = objectOgm.addField(fieldName);
var edge = new GraphDescriptionBuilder().addOutgoingEdge(fieldName);
if (inputValueSchema.isUnionType()) {
if (inputValueSchema.isList()) {
dataField
.addListAsObjectFieldMapping()
.addInterfaceChildDefinition()
.setGraphDescription(edge);
} else {
dataField
.setRelation(edge)
.addInterfaceAsObjectFieldMapping();
}
} else {
var type = inputValueSchema.getTypes().get(0).getType();
var inputValueType = this.structureSchemaFinder.getStructureType(type);
if (inputValueType instanceof ComplexStructureType) {
var inputOgm = this.dynamicOgmProvider.provideGraphMapping(type);
var inputOgmBuilder = new GenericOGMBuilder()
.copyGraphMappingAsBuilder(inputOgm);
if (inputValueSchema.isList()) {
dataField
.addListAsObjectFieldMapping()
.setGraphDescription(edge)
.setChildDefinition(inputOgmBuilder);
} else {
dataField
.setRelation(edge)
.setOgmBuilder(inputOgmBuilder);
}
} else {
var primitiveOgm = this.dynamicOgmProvider.provideOgmForPrimitive(
type,
new FieldDefinition(
fieldName,
inputValueSchema.getMin(),
inputValueSchema.getMax(),
inputValueSchema.getDescription(),
inputValueSchema.getTypes(),
inputValueSchema.getParentDefinitionType()
)
);
var primitiveOgmBuilder = new GenericOGMBuilder().copyGraphMappingAsBuilder(primitiveOgm);
dataField.setOgmBuilder(primitiveOgmBuilder);
}
}
return objectOgm.build();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/GenericAggregateGraphStateModificator.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.aggregategraphstatemodifier.exceptions.CannotModifyAggregateState;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graph.Graph;
import ai.stapi.graphoperations.objectGraphMapper.model.GraphMappingResult;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import java.util.List;
import org.springframework.stereotype.Service;
public class GenericAggregateGraphStateModificator {
private final List<AggregateGraphStateModificator> aggregateGraphStateModificators;
private final OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper;
public GenericAggregateGraphStateModificator(
List<AggregateGraphStateModificator> aggregateGraphStateModificators,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper
) {
this.aggregateGraphStateModificators = aggregateGraphStateModificators;
this.operationDefinitionStructureTypeMapper = operationDefinitionStructureTypeMapper;
}
public GraphMappingResult modify(
String aggregateType,
Graph currentAggregateState,
DynamicCommand command,
EventFactoryModification modificationDefinition,
OperationDefinitionDTO operationDefinitionDTO,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var supporting = this.aggregateGraphStateModificators.stream()
.filter(modificator -> modificator.supports(modificationDefinition))
.toList();
if (supporting.size() != 1) {
throw CannotModifyAggregateState.becauseThereWasNotExactlyOneModificatorForDefinition(
modificationDefinition,
operationDefinitionDTO
);
}
return supporting.get(0).modify(
aggregateType,
currentAggregateState,
command,
modificationDefinition,
this.operationDefinitionStructureTypeMapper.map(operationDefinitionDTO),
missingFieldResolvingStrategy
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/UpsertAggregateGraphStateModificator.java | package ai.stapi.graphsystem.aggregategraphstatemodifier;
import ai.stapi.graph.Graph;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.GraphMappingResult;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.DynamicOgmProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.aggregategraphstatemodifier.exceptions.CannotUpsertToAggregateState;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
public class UpsertAggregateGraphStateModificator extends AbstractAggregateGraphStateModificator {
public UpsertAggregateGraphStateModificator(
GenericObjectGraphMapper objectGraphMapper,
EventFactoryModificationTraverser eventFactoryModificationTraverser,
EventModificatorOgmProvider eventModificatorOgmProvider
) {
super(objectGraphMapper, eventFactoryModificationTraverser, eventModificatorOgmProvider);
}
@Override
public GraphMappingResult modify(
String aggregateType,
Graph currentAggregateState,
DynamicCommand command,
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var mainNodeId = command.getTargetIdentifier();
var inputValueParameterName = modificationDefinition.getInputValueParameterName();
if (inputValueParameterName == null) {
throw CannotUpsertToAggregateState.becauseModificationDefinitionDoesNotHaveInputValueParameterNameSpecified(
modificationDefinition,
operationStructureType,
mainNodeId
);
}
var inputValue = command.getData().get(inputValueParameterName);
if (inputValue == null) {
return new GraphMappingResult(
new Graph(),
List.of()
);
}
var aggregateRepo = currentAggregateState.traversable();
if (!aggregateRepo.nodeExists(mainNodeId, aggregateType)) {
throw CannotUpsertToAggregateState.becauseMainAggregateNodeDoesntExist(
operationStructureType,
modificationDefinition,
mainNodeId
);
}
var traversingStartNode = this.eventFactoryModificationTraverser.getTraversingStartNode(
aggregateType,
command.getTargetIdentifier(),
command.getData(),
modificationDefinition,
operationStructureType,
aggregateRepo
);
var modificationPath = modificationDefinition.getModificationPath();
var splitPath = modificationPath.split("\\.");
var modifiedNode = this.eventFactoryModificationTraverser.traverseToModifiedNode(
traversingStartNode,
splitPath,
operationStructureType,
modificationDefinition
);
var inputValueSchema = operationStructureType.getField(inputValueParameterName);
var fieldName = splitPath[splitPath.length - 1];
var objectOgm = this.eventModificatorOgmProvider.getOgm(modifiedNode, inputValueSchema, fieldName);
var fakedObject = this.getMappedObject(inputValue, modifiedNode, fieldName);
return this.objectGraphMapper.mapToGraph(
objectOgm,
fakedObject,
missingFieldResolvingStrategy
);
}
@Override
public boolean supports(EventFactoryModification modificationDefinition) {
return modificationDefinition.getKind().equals(EventFactoryModification.UPSERT);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/exceptions/CannotAddToAggregateState.java | package ai.stapi.graphsystem.aggregategraphstatemodifier.exceptions;
import ai.stapi.graph.traversableGraphElements.TraversableNode;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class CannotAddToAggregateState extends RuntimeException {
private CannotAddToAggregateState(String becauseMessage) {
super("Cannot add to aggregate state, because " + becauseMessage);
}
public CannotAddToAggregateState(List<CannotAddToAggregateState> cannotAddToAggregateStateList) {
super(
cannotAddToAggregateStateList.stream()
.map(Throwable::getMessage)
.collect(Collectors.joining("\n"))
);
}
public static CannotAddToAggregateState becauseModificationPathIsInvalid(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition
) {
return new CannotAddToAggregateState(
String.format(
"modification path present in modification definition was invalid.%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'",
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
public static CannotAddToAggregateState becauseModificationPathDoesNotStartWithCorrectAggregateType(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition,
String actualAggregateType
) {
return new CannotAddToAggregateState(
String.format(
"modification path does not start with correct aggregate type.%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'%n" +
"Actual aggregate type: '%s'",
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath(),
actualAggregateType
)
);
}
public static CannotAddToAggregateState becauseModificationPathContainsFieldNameNotPresentInSchema(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition
) {
return new CannotAddToAggregateState(
String.format(
"modification path present in modification definition "
+ "contains field name not present in schema.%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'",
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
public static CannotAddToAggregateState becauseModificationPathContainsFieldNameWhichIsPrimitiveButItShouldNot(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition
) {
return new CannotAddToAggregateState(
String.format(
"modification path present in modification definition "
+ "contains field name which is of primitive type, but it is not end of path.%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'",
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
public static CannotAddToAggregateState becauseModificationDefinitionDoesNotHaveInputValueParameterNameSpecified(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition
) {
return new CannotAddToAggregateState(
String.format(
"modification definition does not have input value parameter name specified.%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'",
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
public static CannotAddToAggregateState becauseModifiedNodeSpecifiedByModificationPathWasNotPresent(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition
) {
var modificationPath = modificationDefinition.getModificationPath();
var split = modificationPath.split("\\.");
return new CannotAddToAggregateState(
String.format(
"node to be modified (specified by modification path) was not present in aggregate state.%n"
+
"Operation name: '%s'%nModification kind: '%s'%nExpected present parent node path: %s%nWhole Modification path: '%s'",
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
String.join(".", Arrays.copyOfRange(split, 0, split.length - 1)),
modificationPath
)
);
}
public static CannotAddToAggregateState becauseThereAreIndistinguishableNodes(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition,
String expectedIdSourcePath
) {
return new CannotAddToAggregateState(
String.format(
"modification definition has path which leads through list. %s%n%s%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'",
"But there is no id to distinguish between the items.",
String.format(
"Maybe invalid command handler definition? You can fix this by adding parameter of type id to operation definition with source path: '%s'.",
expectedIdSourcePath
),
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
public static CannotAddToAggregateState becauseThereAreMoreWaysToDistinguisNodes(
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
String sourcePathOfId
) {
return new CannotAddToAggregateState(
String.format(
"modification definition has path which leads through multiple nodes. %s%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'",
String.format(
"But there are multiple parameters on operation definition with source path: '%s'.",
sourcePathOfId),
operationStructureType.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
public static CannotAddToAggregateState becauseThereIsNoNodeWithIdSpecifiedAtSourcePath(
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
String sourcePathOfId,
UniqueIdentifier id
) {
return new CannotAddToAggregateState(
String.format(
"there is no node with id specified at source path.%n" +
"Operation name: '%s'%nNode path: '%s'%nId: '%s'%nModification kind: '%s'%n"
+ "Modification path: '%s'",
operationStructureType.getDefinitionType(),
sourcePathOfId,
id.getId(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
public static CannotAddToAggregateState becauseThereIsNoSourcePathAtStartIdParameterName(
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
UniqueIdentifier id,
String startIdParameterName
) {
return new CannotAddToAggregateState(
String.format(
"there is no node with source path specified at start id parameter name.%n" +
"Operation name: '%s'%nId: '%s'%nModification kind: '%s'%n"
+ "Start id parameter name: '%s'",
operationStructureType.getDefinitionType(),
id.getId(),
modificationDefinition.getKind(),
startIdParameterName
)
);
}
public static CannotAddToAggregateState becauseThereAlreadyIsSuchLeafComplexType(
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
TraversableNode modifiedNode
) {
return new CannotAddToAggregateState(
String.format(
"there already is such singular complex type, but add operation cannot modify existing data. " +
"Use command with upsert modification instead.%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'%nModified node identifier: '%s/%s'",
operationStructureType.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath(),
modifiedNode.getType(),
modifiedNode.getId().getId()
)
);
}
public static CannotAddToAggregateState becauseThereAlreadyIsSuchLeafAttribute(
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
TraversableNode modifiedNode
) {
return new CannotAddToAggregateState(
String.format(
"there already is such leaf attribute, but add operation cannot modify existing data. " +
"Use command with upsert modification instead.%n" +
"Operation name: '%s'%nModification kind: '%s'%nModification path: '%s'%nModified node identifier: '%s/%s'",
operationStructureType.getDefinitionType(),
modificationDefinition.getKind(),
modificationDefinition.getModificationPath(),
modifiedNode.getType(),
modifiedNode.getId().getId()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/exceptions/CannotModifyAggregateState.java | package ai.stapi.graphsystem.aggregategraphstatemodifier.exceptions;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchema.ComplexStructureType;
public class CannotModifyAggregateState extends RuntimeException {
private CannotModifyAggregateState(String becauseMessage) {
super("Cannot modify aggregate state, because " + becauseMessage);
}
public static CannotModifyAggregateState becauseThereWasNotExactlyOneModificatorForDefinition(
EventFactoryModification modificationDefinition,
OperationDefinitionDTO operationDefinition
) {
return new CannotModifyAggregateState(
String.format(
"there was not exactly one modificator for specified modification definition.%n" +
"Modification kind: '%s'%nOperation name: '%s'",
modificationDefinition.getKind(),
operationDefinition.getId()
)
);
}
public static CannotModifyAggregateState becauseThereIsNoIdInCommandAtStartIdParameterName(
String startIdParameterName,
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType
) {
return new CannotModifyAggregateState(
String.format(
"there is no start id value in command at specified start id parameter name. " +
"Probably there is a mistake in modification definition.%n" +
"Operation name: '%s'%nModification kind: '%s'%n"
+ "Start id parameter name: '%s'",
operationStructureType.getDefinitionType(),
modificationDefinition.getKind(),
startIdParameterName
)
);
}
public static CannotModifyAggregateState becauseStartIdIsNotOfCorrectFormat(
String startIdValue,
String startIdParameterName,
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType
) {
return new CannotModifyAggregateState(
String.format(
"start id found at start id parameter name is not of correct format (Type/Id).%n" +
"Operation name: '%s'%nModification kind: '%s'%n"
+ "Start id parameter name: '%s'%nStart id value: '%s'",
operationStructureType.getDefinitionType(),
modificationDefinition.getKind(),
startIdParameterName,
startIdValue
)
);
}
public static CannotModifyAggregateState becauseThereIsNoNodeWithIdSpecifiedAtStartIdParameterName(
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
UniqueIdentifier id,
String startIdParameterName
) {
return new CannotModifyAggregateState(
String.format(
"there is no node with id specified at start id parameter name.%n" +
"Operation name: '%s'%nId: '%s'%nModification kind: '%s'%n"
+ "Start id parameter name: '%s'",
operationStructureType.getDefinitionType(),
id.getId(),
modificationDefinition.getKind(),
startIdParameterName
)
);
}
public static CannotModifyAggregateState becauseThereAreEdgesOnPathEvenThoughtThereShouldBeMaxOne(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition,
String multipleEdgesPath
) {
return new CannotModifyAggregateState(
String.format(
"there are multiple edge on path event thought ther should be max one by schema.%n" +
"Operation name: '%s'%nModification kind: '%s'%nMultiple edges path: '%s'%nModification path: '%s'",
operationDefinition.getDefinitionType(),
modificationDefinition.getKind(),
multipleEdgesPath,
modificationDefinition.getModificationPath()
)
);
}
public static CannotModifyAggregateState becauseThereAreIsNodeEdgeOnPathEvenThoughtThereShouldBeOne(
EventFactoryModification modificationDefinition,
ComplexStructureType operationDefinition,
String multipleEdgesPath
) {
return new CannotModifyAggregateState(
String.format(
"the node you are trying to modify should already exist. Please add it first with appropriate command.%n"
+
"Operation name: '%s'%nMissing node path: '%s'%nModification kind: '%s'%nModification path: '%s'",
operationDefinition.getDefinitionType(),
multipleEdgesPath,
modificationDefinition.getKind(),
modificationDefinition.getModificationPath()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/aggregategraphstatemodifier/exceptions/CannotUpsertToAggregateState.java | package ai.stapi.graphsystem.aggregategraphstatemodifier.exceptions;
import ai.stapi.graphsystem.aggregatedefinition.model.CommandHandlerDefinitionDTO;
import ai.stapi.graphsystem.aggregatedefinition.model.EventFactoryModification;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.structureSchema.ComplexStructureType;
public class CannotUpsertToAggregateState extends RuntimeException {
private CannotUpsertToAggregateState(String becauseMessage) {
super("Cannot upsert to Aggregate state, because " + becauseMessage);
}
public static CannotUpsertToAggregateState becauseMainAggregateNodeDoesntExist(
ComplexStructureType operationStructureType,
EventFactoryModification modificationDefinition,
UniqueIdentifier mainNodeId
) {
return new CannotUpsertToAggregateState(
String.format(
"main aggregate node doesnt exist.%nOperation name: '%s'%nModification path: '%s'%nMain node id: '%s'",
operationStructureType.getDefinitionType(),
modificationDefinition.getModificationPath(),
mainNodeId.getId()
)
);
}
public static CannotUpsertToAggregateState becauseModificationDefinitionDoesNotHaveInputValueParameterNameSpecified(
EventFactoryModification modificationDefinition,
ComplexStructureType operationStructureType,
UniqueIdentifier mainNodeId
) {
return new CannotUpsertToAggregateState(
String.format(
"modification definition does not have input value parameter name specified.%n" +
"Operation name: '%s'%nModification path: '%s'%nMain node id: '%s'",
operationStructureType.getDefinitionType(),
modificationDefinition.getModificationPath(),
mainNodeId.getId()
)
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandEventGraphMappingProvider/GenericCommandEventGraphMappingProvider.java | package ai.stapi.graphsystem.commandEventGraphMappingProvider;
import ai.stapi.graphsystem.commandEventGraphMappingProvider.exception.GraphMappingProviderException;
import ai.stapi.graphsystem.commandEventGraphMappingProvider.specific.SpecificCommandEventGraphMappingProvider;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
public class GenericCommandEventGraphMappingProvider {
private final List<SpecificCommandEventGraphMappingProvider> mappingProviders;
public GenericCommandEventGraphMappingProvider(
List<SpecificCommandEventGraphMappingProvider> mappingProviders
) {
this.mappingProviders = mappingProviders;
}
public Map<Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>>, ObjectGraphMapping> provideGraphMappings(
AbstractCommand<? extends UniqueIdentifier> command
) {
return this.resolveAllProviders(command);
}
public boolean containsFor(AbstractCommand<? extends UniqueIdentifier> command) {
return this.mappingProviders.stream().anyMatch(
specificObjectGraphMapper -> specificObjectGraphMapper.supports(
command.getSerializationType()
)
);
}
private HashMap<Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>>, ObjectGraphMapping> resolveAllProviders(
AbstractCommand<? extends UniqueIdentifier> command
) {
var collectedProviderResults =
new HashMap<Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>>, ObjectGraphMapping>();
var providers = this.getSupportingProviders(command.getSerializationType());
providers.stream()
.map(provider -> provider.provideGraphMapping(command))
.forEach(collectedProviderResults::putAll);
return collectedProviderResults;
}
private List<SpecificCommandEventGraphMappingProvider> getSupportingProviders(
String deserializationType
) {
var listOfSupportingProviders = this.mappingProviders.stream()
.filter(
specificObjectGraphMapper -> specificObjectGraphMapper.supports(deserializationType))
.toList();
if (listOfSupportingProviders.isEmpty()) {
throw GraphMappingProviderException.becauseThereIsNoSupportingSpecificGraphMappingProvider(
deserializationType);
}
return listOfSupportingProviders;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandEventGraphMappingProvider | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandEventGraphMappingProvider/exception/GraphMappingProviderException.java | package ai.stapi.graphsystem.commandEventGraphMappingProvider.exception;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphsystem.commandEventGraphMappingProvider.specific.SpecificCommandEventGraphMappingProvider;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
public class GraphMappingProviderException extends RuntimeException {
private GraphMappingProviderException(String message) {
super(message);
}
public static GraphMappingProviderException becauseThereIsNoSupportingSpecificGraphMappingProvider(
String deserializationType) {
return new GraphMappingProviderException(
String.format(
"\nThere is no supporting %s"
+ " for object of type:\n%s",
SpecificCommandEventGraphMappingProvider.class.getSimpleName(),
deserializationType
)
);
}
public static GraphMappingProviderException becauseThereAreMoreThanOneSpecificGraphMappingProviders(
Class<?> classType,
List<SpecificCommandEventGraphMappingProvider> listOfSupportingProviders
) {
return new GraphMappingProviderException(
"Object of type '"
+ classType.getSimpleName()
+ "' is supported by multiple providers ("
+ StringUtils.join(listOfSupportingProviders, ", ")
+ ") and that is not allowed."
);
}
public static GraphMappingProviderException becauseCommandDoesNotContainGivenField(
Class<? extends AbstractCommand> classType,
String fieldName
) {
return new GraphMappingProviderException(
"Command of type '" + classType.getSimpleName() + "' does not contain field with name '"
+ fieldName + "'."
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandEventGraphMappingProvider | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandEventGraphMappingProvider/specific/SpecificCommandEventGraphMappingProvider.java | package ai.stapi.graphsystem.commandEventGraphMappingProvider.specific;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphLanguage.ObjectGraphMapping;
import java.util.Map;
public interface SpecificCommandEventGraphMappingProvider {
Map<Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>>, ObjectGraphMapping> provideGraphMapping(
AbstractCommand<? extends UniqueIdentifier> command
);
boolean supports(String serializationType);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/ExtraFieldCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.AbstractCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public class ExtraFieldCommandViolation extends AbstractCommandConstrainViolation {
public ExtraFieldCommandViolation(String commandName, CommandViolationFieldPath fieldPath) {
super(commandName, fieldPath, Level.WARNING);
}
@Override
protected String getBecauseMessage() {
return "It is extra field.";
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/FieldCardinalityCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.AbstractCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public class FieldCardinalityCommandViolation extends AbstractCommandConstrainViolation {
private final Integer actualSize;
private final Integer requiredMin;
private final String requiredMax;
public FieldCardinalityCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Integer actualSize,
Integer requiredMin,
String requiredMax
) {
super(commandName, fieldPath, Level.ERROR);
this.actualSize = actualSize;
this.requiredMin = requiredMin;
this.requiredMax = requiredMax;
}
@Override
protected String getBecauseMessage() {
return String.format(
"Wrong cardinality. Required size should be %s. Actual size was: %s.",
this.getRequiredSizeMessage(),
this.actualSize
);
}
public Integer getActualSize() {
return actualSize;
}
public Integer getRequiredMin() {
return requiredMin;
}
public String getRequiredMax() {
return requiredMax;
}
private String getRequiredSizeMessage() {
if (this.requiredMax.equals("*")) {
return String.format("higher than %s", this.requiredMin);
}
return String.format("between %s-%s", this.requiredMin, this.requiredMax);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/FieldStructureTypeCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.ActualValueCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public class FieldStructureTypeCommandViolation extends ActualValueCommandConstrainViolation {
private final boolean shouldBeList;
private FieldStructureTypeCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue,
boolean shouldBeList
) {
super(commandName, fieldPath, Level.ERROR, actualValue);
this.shouldBeList = shouldBeList;
}
public static FieldStructureTypeCommandViolation notList(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue
) {
return new FieldStructureTypeCommandViolation(
commandName,
fieldPath,
actualValue,
true
);
}
public static FieldStructureTypeCommandViolation notSingle(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue
) {
return new FieldStructureTypeCommandViolation(
commandName,
fieldPath,
actualValue,
false
);
}
@Override
protected String getBecauseMessage() {
return String.format(
"Field had %s is required.",
this.shouldBeList ? "single value, but list" : "list of values, but only single value"
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/InvalidComplexTypeCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.ActualValueCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
import org.jetbrains.annotations.Nullable;
public class InvalidComplexTypeCommandViolation extends ActualValueCommandConstrainViolation {
private final String requiredType;
private final Throwable cause;
public InvalidComplexTypeCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue,
String requiredType,
Throwable cause
) {
super(commandName, fieldPath, Level.ERROR, actualValue);
this.requiredType = requiredType;
this.cause = cause;
}
@Override
protected String getBecauseMessage() {
return "Complex type was not Object. Required type: " + this.requiredType;
}
@Nullable
public Throwable getCause() {
return cause;
}
public String getRequiredType() {
return requiredType;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/InvalidPrimitiveTypeCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.ActualValueCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public class InvalidPrimitiveTypeCommandViolation extends ActualValueCommandConstrainViolation {
private final String dataType;
public InvalidPrimitiveTypeCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
String dataType,
Object actualValue
) {
super(commandName, fieldPath, Level.ERROR, actualValue);
this.dataType = dataType;
}
@Override
protected String getBecauseMessage() {
return String.format(
"Primitive value was of invalid data type. Required data type: %s.",
this.dataType
);
}
public String getDataType() {
return dataType;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/InvalidReferenceTypeCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.ActualValueCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
import org.jetbrains.annotations.Nullable;
public class InvalidReferenceTypeCommandViolation extends ActualValueCommandConstrainViolation {
@Nullable
private Throwable cause;
public InvalidReferenceTypeCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue
) {
super(commandName, fieldPath, Level.ERROR, actualValue);
}
public InvalidReferenceTypeCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue,
Throwable cause
) {
this(commandName, fieldPath, actualValue);
this.cause = cause;
}
@Override
protected String getBecauseMessage() {
return "Reference value was invalid. Object with single string field under key 'id' is required.";
}
@Nullable
public Throwable getCause() {
return cause;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/InvalidUnionMemberCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.ActualValueCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import org.jetbrains.annotations.Nullable;
public class InvalidUnionMemberCommandViolation extends ActualValueCommandConstrainViolation {
@Nullable
private Throwable cause;
public InvalidUnionMemberCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue
) {
super(commandName, fieldPath, Level.ERROR, actualValue);
}
public InvalidUnionMemberCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualValue,
Throwable cause
) {
this(commandName, fieldPath, actualValue);
this.cause = cause;
}
@Override
protected String getBecauseMessage() {
var message = "Union member was invalid. Object with string field under key '%s' is required.";
return String.format(
message,
DynamicCommand.SERIALIZATION_TYPE_FIELD_NAME
);
}
@Nullable
public Throwable getCause() {
return cause;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/InvalidUnionMemberTypeCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.AbstractCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
import java.util.List;
public class InvalidUnionMemberTypeCommandViolation extends AbstractCommandConstrainViolation {
private final Object actualMemberType;
private final List<String> possibleMemberTypes;
public InvalidUnionMemberTypeCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Object actualMemberType,
List<String> possibleMemberTypes
) {
super(commandName, fieldPath, Level.ERROR);
this.actualMemberType = actualMemberType;
this.possibleMemberTypes = possibleMemberTypes;
}
@Override
protected String getBecauseMessage() {
var message = "Union member type is not allowed in union. " +
"Actual member type: %s\n" +
"Possible member types: %s";
return String.format(
message,
this.actualMemberType,
this.possibleMemberTypes
);
}
public Object getActualMemberType() {
return actualMemberType;
}
public List<String> getPossibleMemberTypes() {
return possibleMemberTypes;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/MissingRequiredFieldCommandViolation.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graphsystem.commandvalidation.model.AbstractCommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public class MissingRequiredFieldCommandViolation extends AbstractCommandConstrainViolation {
public MissingRequiredFieldCommandViolation(
String commandName,
CommandViolationFieldPath fieldPath
) {
super(commandName, fieldPath, Level.ERROR);
}
@Override
protected String getBecauseMessage() {
return "Required field is missing.";
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/infrastructure/operationdefinition/OperationDefinitionCommandValidator.java | package ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition;
import ai.stapi.graph.attribute.attributeFactory.attributeValueFactory.GenericAttributeValueFactory;
import ai.stapi.graph.attribute.attributeValue.IdAttributeValue;
import ai.stapi.graphsystem.commandvalidation.model.CommandConstrainViolation;
import ai.stapi.graphsystem.commandvalidation.model.CommandValidator;
import ai.stapi.graphsystem.commandvalidation.model.exceptions.CannotValidateCommand;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.messaging.command.AbstractPayloadCommand;
import ai.stapi.graphsystem.messaging.command.Command;
import ai.stapi.graphsystem.operationdefinition.exceptions.CannotProvideOperationDefinition;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionDTO;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.schema.structureSchema.AbstractStructureType;
import ai.stapi.schema.structureSchema.ComplexStructureType;
import ai.stapi.schema.structureSchema.FieldDefinition;
import ai.stapi.schema.structureSchema.FieldType;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import ai.stapi.schema.structureSchemaProvider.exception.CannotProvideStructureSchema;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
public class OperationDefinitionCommandValidator implements CommandValidator {
private final OperationDefinitionProvider operationDefinitionProvider;
private final StructureSchemaProvider structureSchemaProvider;
private final OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper;
private final GenericAttributeValueFactory genericAttributeValueFactory;
private final ObjectMapper objectMapper;
public OperationDefinitionCommandValidator(
OperationDefinitionProvider operationDefinitionProvider,
StructureSchemaProvider structureSchemaProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper,
GenericAttributeValueFactory genericAttributeValueFactory,
ObjectMapper objectMapper
) {
this.operationDefinitionProvider = operationDefinitionProvider;
this.structureSchemaProvider = structureSchemaProvider;
this.operationDefinitionStructureTypeMapper = operationDefinitionStructureTypeMapper;
this.genericAttributeValueFactory = genericAttributeValueFactory;
this.objectMapper = objectMapper;
}
@Override
public List<CommandConstrainViolation> validate(Command command) {
var commandName = command.getSerializationType();
OperationDefinitionDTO operationDefinition;
try {
operationDefinition = this.operationDefinitionProvider.provide(commandName);
} catch (CannotProvideOperationDefinition e) {
throw CannotValidateCommand.becauseThereWasNoOperationDefinition(commandName, e);
}
var fakedStructureType = this.operationDefinitionStructureTypeMapper.map(operationDefinition);
var commandPayload = this.extractCommandPayload(command);
return this.validateRecursively(
commandPayload,
fakedStructureType,
new CommandViolationFieldPath(),
commandName
);
}
private List<CommandConstrainViolation> validateRecursively(
Map<String, Object> dataObject,
ComplexStructureType structureType,
CommandViolationFieldPath fieldPath,
String commandName
) {
var violations = new ArrayList<CommandConstrainViolation>();
var extraFieldsViolations = this.validateExtraFields(
dataObject,
structureType,
fieldPath,
commandName
);
violations.addAll(extraFieldsViolations);
var requiredFieldsViolations = this.validateRequiredFields(
dataObject,
structureType,
fieldPath,
commandName
);
violations.addAll(requiredFieldsViolations);
structureType.getAllFields().values().stream().map(
fieldDefinition -> this.validateField(
fieldDefinition,
dataObject.get(fieldDefinition.getName()),
fieldPath.add(fieldDefinition.getName()),
commandName
)
).forEach(violations::addAll);
return violations;
}
private List<CommandConstrainViolation> validateExtraFields(
Map<String, Object> commandPayload,
ComplexStructureType structureType,
CommandViolationFieldPath fieldPath,
String commandName
) {
var definedFields = structureType.getAllFields().keySet();
return commandPayload.keySet().stream()
.filter(fieldName -> !definedFields.contains(fieldName))
.map(fieldPath::add)
.map(newFieldPath -> new ExtraFieldCommandViolation(commandName, newFieldPath))
.map(CommandConstrainViolation.class::cast)
.toList();
}
private List<CommandConstrainViolation> validateRequiredFields(
Map<String, Object> commandPayload,
ComplexStructureType structureType,
CommandViolationFieldPath fieldPath,
String commandName
) {
var requiredFields = structureType.getAllFields().entrySet().stream()
.filter(entry -> entry.getValue().isRequired())
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
return requiredFields.stream()
.filter(fieldName -> commandPayload.get(fieldName) == null)
.map(fieldPath::add)
.map(newFieldPath -> new MissingRequiredFieldCommandViolation(commandName, newFieldPath))
.map(CommandConstrainViolation.class::cast)
.toList();
}
private List<CommandConstrainViolation> validateField(
FieldDefinition fieldDefinition,
Object fieldValue,
CommandViolationFieldPath fieldPath,
String commandName
) {
//Required fields had already been checked, if null no further validation needed
if (fieldValue == null) {
return List.of();
}
if (fieldDefinition.isList()) {
return this.validateListField(fieldDefinition, fieldValue, fieldPath, commandName);
} else {
return this.validateSingleValueField(fieldDefinition, fieldValue, fieldPath, commandName);
}
}
private List<CommandConstrainViolation> validateListField(
FieldDefinition fieldDefinition,
Object fieldValue,
CommandViolationFieldPath fieldPath,
String commandName
) {
if (!(fieldValue instanceof List<?> listFieldValue)) {
return List.of(
FieldStructureTypeCommandViolation.notList(
commandName,
fieldPath,
fieldValue
)
);
}
var violations = new ArrayList<CommandConstrainViolation>();
var actualSize = listFieldValue.size();
if (actualSize < fieldDefinition.getMin() || actualSize > fieldDefinition.getFloatMax()) {
violations.add(
new FieldCardinalityCommandViolation(
commandName,
fieldPath,
actualSize,
fieldDefinition.getMin(),
fieldDefinition.getMax()
)
);
}
for (int index = 0; index < actualSize; index++) {
var itemViolations = this.validateValue(
fieldDefinition,
listFieldValue.get(index),
fieldPath.add("" + index),
commandName
);
violations.addAll(itemViolations);
}
return violations;
}
private List<CommandConstrainViolation> validateSingleValueField(
FieldDefinition fieldDefinition,
Object fieldValue,
CommandViolationFieldPath fieldPath,
String commandName
) {
if (fieldValue instanceof List<?>) {
return List.of(
FieldStructureTypeCommandViolation.notSingle(
commandName,
fieldPath,
fieldValue
)
);
}
return this.validateValue(
fieldDefinition,
fieldValue,
fieldPath,
commandName
);
}
private List<CommandConstrainViolation> validateValue(
FieldDefinition fieldDefinition,
Object value,
CommandViolationFieldPath fieldPath,
String commandName
) {
//If it is any type, there are no validations to be done
if (fieldDefinition.isAnyType()) {
return List.of();
}
if (fieldDefinition.isUnionType()) {
return this.validateUnionMember(fieldDefinition, value, fieldPath, commandName);
}
var type = fieldDefinition.getTypes().get(0);
if (type.isReference()) {
return this.validateReference(value, fieldPath, commandName);
}
if (type.isPrimitiveType()) {
return validatePrimitive(type.getType(), value, fieldPath, commandName);
}
return this.validateComplex(type, value, fieldPath, commandName);
}
@NotNull
private List<CommandConstrainViolation> validateUnionMember(
FieldDefinition fieldDefinition,
Object value,
CommandViolationFieldPath fieldPath,
String commandName
) {
Map<String, Object> map;
try {
map = this.objectMapper.convertValue(value, new TypeReference<>() {
});
} catch (IllegalArgumentException cause) {
return List.of(
new InvalidUnionMemberCommandViolation(commandName, fieldPath, value, cause)
);
}
var memberType = map.get(DynamicCommand.SERIALIZATION_TYPE_FIELD_NAME);
if (memberType == null) {
return List.of(
new InvalidUnionMemberCommandViolation(commandName, fieldPath, value)
);
}
var possibleMemberTypes = fieldDefinition.getTypes().stream().map(FieldType::getType).toList();
if (!(memberType instanceof String stringMemberType) || !possibleMemberTypes.contains(
memberType)) {
return List.of(
new InvalidUnionMemberTypeCommandViolation(
commandName,
fieldPath,
memberType,
possibleMemberTypes
)
);
}
var strippedMap = new HashMap<String, Object>();
map.entrySet().stream()
.filter(entry -> !entry.getKey().equals(DynamicCommand.SERIALIZATION_TYPE_FIELD_NAME))
.forEach(entry -> strippedMap.put(entry.getKey(), entry.getValue()));
AbstractStructureType memberStructureType = null;
try {
memberStructureType = this.structureSchemaProvider.provideSpecific(stringMemberType);
} catch (CannotProvideStructureSchema e) {
throw new RuntimeException(e);
}
var memberFieldType = fieldDefinition.getTypes().stream()
.filter(fieldType -> fieldType.getType().equals(stringMemberType))
.findFirst()
.orElseThrow();
return this.validateRecursively(
strippedMap,
(ComplexStructureType) memberStructureType,
memberFieldType.isAnonymous() ? fieldPath : fieldPath.setTypeNameToLast(stringMemberType),
commandName
);
}
private List<CommandConstrainViolation> validateReference(
Object value,
CommandViolationFieldPath fieldPath,
String commandName
) {
Map<String, Object> map;
try {
map = this.objectMapper.convertValue(value, new TypeReference<>() {
});
} catch (IllegalArgumentException cause) {
return List.of(
new InvalidReferenceTypeCommandViolation(commandName, fieldPath, value, cause)
);
}
if (map.size() != 1) {
return List.of(
new InvalidReferenceTypeCommandViolation(commandName, fieldPath, value)
);
}
var id = map.get("id");
if (id == null) {
return List.of(
new InvalidReferenceTypeCommandViolation(commandName, fieldPath, value)
);
}
if (!this.genericAttributeValueFactory.isValidValue(IdAttributeValue.SERIALIZATION_TYPE, id)) {
return List.of(
new InvalidReferenceTypeCommandViolation(commandName, fieldPath, value)
);
}
return List.of();
}
@NotNull
private List<CommandConstrainViolation> validatePrimitive(
String type,
Object value,
CommandViolationFieldPath fieldPath,
String commandName
) {
if (this.genericAttributeValueFactory.isValidValue(type, value)) {
return List.of();
}
return List.of(
new InvalidPrimitiveTypeCommandViolation(commandName, fieldPath, type, value)
);
}
@NotNull
private List<CommandConstrainViolation> validateComplex(
FieldType type,
Object value,
CommandViolationFieldPath fieldPath,
String commandName
) {
var stringType = type.getType();
Map<String, Object> map;
try {
map = this.objectMapper.convertValue(value, new TypeReference<>() {
});
} catch (IllegalArgumentException cause) {
return List.of(
new InvalidComplexTypeCommandViolation(commandName, fieldPath, value, stringType, cause)
);
}
ComplexStructureType structureType;
try {
structureType =
(ComplexStructureType) this.structureSchemaProvider.provideSpecific(stringType);
} catch (CannotProvideStructureSchema e) {
throw new RuntimeException(e);
}
return this.validateRecursively(
map,
structureType,
type.isAnonymous() ? fieldPath : fieldPath.setTypeNameToLast(stringType),
commandName
);
}
private Map<String, Object> extractCommandPayload(Command command) {
if (command instanceof AbstractPayloadCommand<?> createResourceCommand) {
return createResourceCommand.getData();
}
var serializedCommand = this.objectMapper.convertValue(
command,
new TypeReference<Map<String, Object>>() {
}
);
var commandPayload = new HashMap<String, Object>();
var fieldsToFilterOut = List.of(
DynamicCommand.TARGET_IDENTIFIER_FIELD_NAME,
DynamicCommand.SERIALIZATION_TYPE_FIELD_NAME
);
serializedCommand.entrySet().stream()
.filter(entry -> !fieldsToFilterOut.contains(entry.getKey()))
.forEach(entry -> commandPayload.put(entry.getKey(), entry.getValue()));
return commandPayload;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/AbstractCommandConstrainViolation.java | package ai.stapi.graphsystem.commandvalidation.model;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public abstract class AbstractCommandConstrainViolation implements CommandConstrainViolation {
private final String commandName;
private final CommandViolationFieldPath fieldPath;
private final Level level;
protected AbstractCommandConstrainViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Level level
) {
this.commandName = commandName;
this.fieldPath = fieldPath;
this.level = level;
}
protected abstract String getBecauseMessage();
@Override
public String getCommandName() {
return commandName;
}
@Override
public CommandViolationFieldPath getFieldPath() {
return fieldPath;
}
@Override
public String getMessage() {
return String.format(
"[%s] Command with name: '%s' did not validate.\nField path: %s\n%s",
this.level,
this.commandName,
this.renderFieldPath(),
this.getBecauseMessage()
);
}
@Override
public Level getLevel() {
return level;
}
private String renderFieldPath() {
return this.commandName + this.fieldPath.renderPath();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/ActualValueCommandConstrainViolation.java | package ai.stapi.graphsystem.commandvalidation.model;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public abstract class ActualValueCommandConstrainViolation
extends AbstractCommandConstrainViolation {
private final Object actualValue;
private final ObjectWriter objectWriter;
protected ActualValueCommandConstrainViolation(
String commandName,
CommandViolationFieldPath fieldPath,
Level level,
Object actualValue
) {
super(commandName, fieldPath, level);
this.actualValue = actualValue;
this.objectWriter = new ObjectMapper().writerWithDefaultPrettyPrinter();
}
@Override
public String getMessage() {
return super.getMessage() + "\nActual value: " + this.renderActualValue();
}
private String renderActualValue() {
try {
return this.objectWriter.writeValueAsString(this.actualValue);
} catch (JsonProcessingException e) {
return this.actualValue.toString();
}
}
public Object getActualValue() {
return actualValue;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/CommandConstrainViolation.java | package ai.stapi.graphsystem.commandvalidation.model;
import ai.stapi.graphsystem.commandvalidation.model.fieldPath.CommandViolationFieldPath;
public interface CommandConstrainViolation {
String getCommandName();
CommandViolationFieldPath getFieldPath();
String getMessage();
Level getLevel();
enum Level {
ERROR,
WARNING
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/CommandValidator.java | package ai.stapi.graphsystem.commandvalidation.model;
import ai.stapi.graphsystem.messaging.command.Command;
import java.util.List;
public interface CommandValidator {
List<CommandConstrainViolation> validate(Command command);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/exceptions/CannotDispatchCommand.java | package ai.stapi.graphsystem.commandvalidation.model.exceptions;
import ai.stapi.graphsystem.commandvalidation.model.CommandConstrainViolation;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class CannotDispatchCommand extends RuntimeException {
private final transient List<CommandConstrainViolation> commandConstrainViolations;
private CannotDispatchCommand(
String commandName,
String becauseMessage,
List<CommandConstrainViolation> commandConstrainViolations
) {
super(
String.format(
"Cannot dispatch Command '%s', %s",
commandName,
becauseMessage
)
);
this.commandConstrainViolations = commandConstrainViolations;
}
public static CannotDispatchCommand becauseThereWereConstrainViolation(
String commandName,
String targetAggregateIdentifier,
List<CommandConstrainViolation> commandConstrainViolations
) {
return new CannotDispatchCommand(
commandName,
("""
because there were constrain violations.
Target Aggregate Identifier: '%s'
%s
"""
).formatted(
targetAggregateIdentifier,
commandConstrainViolations.stream()
.sorted(Comparator.comparing(CommandConstrainViolation::getLevel))
.map(CommandConstrainViolation::getMessage)
.collect(Collectors.joining("\n\n"))
),
commandConstrainViolations
);
}
public static CannotDispatchCommand becauseItDoesNotImplementCommandInterface(
String commandName,
Class<?> actualClass
) {
return new CannotDispatchCommand(
commandName,
"because it does not implement Command interface. Actual className: "
+ actualClass.getSimpleName(),
List.of()
);
}
public List<CommandConstrainViolation> getCommandConstrainViolations() {
return commandConstrainViolations;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/exceptions/CannotValidateCommand.java | package ai.stapi.graphsystem.commandvalidation.model.exceptions;
public class CannotValidateCommand extends RuntimeException {
private CannotValidateCommand(String commandName, String becauseMessage) {
super(String.format("Cannot validate command: '%s', because %s", commandName, becauseMessage));
}
private CannotValidateCommand(String commandName, String becauseMessage, Throwable cause) {
super(
String.format("Cannot validate command: '%s', because %s", commandName, becauseMessage),
cause
);
}
public static CannotValidateCommand becauseThereWasNoOperationDefinition(String commandName) {
return new CannotValidateCommand(
commandName,
"there was no Operation Definition to be found."
);
}
public static CannotValidateCommand becauseThereWasNoOperationDefinition(
String commandName,
Throwable cause
) {
return new CannotValidateCommand(
commandName,
"there was no Operation Definition to be found.",
cause
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/fieldPath/CommandViolationFieldPath.java | package ai.stapi.graphsystem.commandvalidation.model.fieldPath;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class CommandViolationFieldPath {
private final List<CommandViolationFieldPathPart> commandViolationFieldPathParts;
public CommandViolationFieldPath() {
this.commandViolationFieldPathParts = new ArrayList<>();
}
private CommandViolationFieldPath(
List<CommandViolationFieldPathPart> commandViolationFieldPathParts
) {
this.commandViolationFieldPathParts = commandViolationFieldPathParts;
}
@NotNull
public CommandViolationFieldPath add(CommandViolationFieldPathPart newPart) {
var newFieldPath = new ArrayList<>(this.commandViolationFieldPathParts);
newFieldPath.add(newPart);
return new CommandViolationFieldPath(newFieldPath);
}
@NotNull
public CommandViolationFieldPath add(String fieldName, @Nullable String typeName) {
return this.add(
new CommandViolationFieldPathPart(fieldName, typeName)
);
}
@NotNull
public CommandViolationFieldPath add(String fieldName) {
return this.add(fieldName, null);
}
public CommandViolationFieldPath setTypeNameToLast(String typeName) {
var last = this.commandViolationFieldPathParts.size() - 1;
this.commandViolationFieldPathParts.get(last).setTypeName(typeName);
return this;
}
public String renderPath() {
return this.commandViolationFieldPathParts.stream()
.map(CommandViolationFieldPathPart::render)
.collect(Collectors.joining());
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/commandvalidation/model/fieldPath/CommandViolationFieldPathPart.java | package ai.stapi.graphsystem.commandvalidation.model.fieldPath;
import org.jetbrains.annotations.Nullable;
public class CommandViolationFieldPathPart {
private final String fieldName;
@Nullable
private String typeName;
public CommandViolationFieldPathPart(String fieldName) {
this.fieldName = fieldName;
}
public CommandViolationFieldPathPart(String fieldName, @Nullable String typeName) {
this.fieldName = fieldName;
this.typeName = typeName;
}
public String getFieldName() {
return fieldName;
}
@Nullable
public String getTypeName() {
return typeName;
}
public void setTypeName(@Nullable String typeName) {
this.typeName = typeName;
}
public String render() {
var type = this.isTypeNameSet() ? String.format("<%s>", this.getTypeName()) : "";
var fieldName = this.getFieldName();
try {
Integer.parseInt(fieldName);
} catch (IllegalArgumentException e) {
return String.format(".%s%s", fieldName, type);
}
return String.format("[%s]%s", fieldName, type);
}
private boolean isTypeNameSet() {
return this.getTypeName() != null && !this.getTypeName().isBlank();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/AggregateDefinitionConfiguration.java | package ai.stapi.graphsystem.configuration;
import ai.stapi.graphsystem.aggregatedefinition.infrastructure.AdHocAggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
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.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.schema.adHocLoaders.GenericAdHocModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
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;
@AutoConfiguration
public class AggregateDefinitionConfiguration {
@Bean
@ConditionalOnMissingBean(AggregateDefinitionProvider.class)
public AdHocAggregateDefinitionProvider adHocAggregateDefinitionProvider(
GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader,
ScopeCacher scopeCacher,
OperationDefinitionProvider operationDefinitionProvider
) {
return new AdHocAggregateDefinitionProvider(
genericAdHocModelDefinitionsLoader,
scopeCacher,
operationDefinitionProvider
);
}
@Bean
public ResourceAggregateDefinitionMapper resourceAggregateDefinitionMapper() {
return new ResourceAggregateDefinitionMapper();
}
@Bean
public CreatedOperationEventFactoriesMapper createdOperationEventFactoriesMapper(
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper,
@Lazy AggregateDefinitionProvider aggregateDefinitionProvider
) {
return new CreatedOperationEventFactoriesMapper(
operationDefinitionStructureTypeMapper,
aggregateDefinitionProvider
);
}
@Bean
public ItemAddedOperationEventFactoriesMapper itemAddedOperationEventFactoriesMapper(
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper
) {
return new ItemAddedOperationEventFactoriesMapper(operationDefinitionStructureTypeMapper);
}
@Bean
public UpdatedOperationEventFactoriesMapper updatedOperationEventFactoriesMapper(
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper,
@Lazy AggregateDefinitionProvider aggregateDefinitionProvider
) {
return new UpdatedOperationEventFactoriesMapper(
operationDefinitionStructureTypeMapper,
aggregateDefinitionProvider
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/CommandValidationConfiguration.java | package ai.stapi.graphsystem.configuration;
import ai.stapi.graph.attribute.attributeFactory.attributeValueFactory.GenericAttributeValueFactory;
import ai.stapi.graphsystem.commandvalidation.infrastructure.operationdefinition.OperationDefinitionCommandValidator;
import ai.stapi.graphsystem.commandvalidation.model.CommandValidator;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class CommandValidationConfiguration {
@Bean
@ConditionalOnMissingBean(CommandValidator.class)
public OperationDefinitionCommandValidator operationDefinitionCommandValidator(
OperationDefinitionProvider operationDefinitionProvider,
StructureSchemaProvider structureSchemaProvider,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper,
GenericAttributeValueFactory genericAttributeValueFactory,
ObjectMapper objectMapper
) {
return new OperationDefinitionCommandValidator(
operationDefinitionProvider,
structureSchemaProvider,
operationDefinitionStructureTypeMapper,
genericAttributeValueFactory,
objectMapper
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/DynamicCommandProcessorConfiguration.java | package ai.stapi.graphsystem.configuration;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.ogmProviders.specific.dynamicObjectGraphMappingProvider.DynamicOgmProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregategraphstatemodifier.*;
import ai.stapi.graphsystem.commandEventGraphMappingProvider.GenericCommandEventGraphMappingProvider;
import ai.stapi.graphsystem.commandEventGraphMappingProvider.specific.SpecificCommandEventGraphMappingProvider;
import ai.stapi.graphsystem.dynamiccommandprocessor.BasicDynamicCommandProcessor;
import ai.stapi.graphsystem.dynamiccommandprocessor.DynamicCommandProcessor;
import ai.stapi.graphsystem.dynamiccommandprocessor.GenericDynamicCommandProcessor;
import ai.stapi.graphsystem.dynamiccommandprocessor.SpecificDynamicCommandProcessor;
import ai.stapi.graphsystem.genericGraphEventFactory.GenericGraphEventFactory;
import ai.stapi.graphsystem.genericGraphEventFactory.specific.SpecificGraphEventFactory;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import java.util.List;
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;
@AutoConfiguration
public class DynamicCommandProcessorConfiguration {
@Bean
@ConditionalOnMissingBean(DynamicCommandProcessor.class)
public GenericDynamicCommandProcessor genericDynamicCommandProcessor(
List<SpecificDynamicCommandProcessor> specificDynamicCommandProcessors
) {
return new GenericDynamicCommandProcessor(specificDynamicCommandProcessors);
}
@Bean
@ConditionalOnBean(GenericDynamicCommandProcessor.class)
public BasicDynamicCommandProcessor basicDynamicCommandProcessor(
GenericObjectGraphMapper objectGraphMapper,
GenericGraphEventFactory genericEventFactory,
GenericCommandEventGraphMappingProvider commandEventGraphMappingProvider
) {
return new BasicDynamicCommandProcessor(
objectGraphMapper,
genericEventFactory,
commandEventGraphMappingProvider
);
}
@Bean
@ConditionalOnBean(BasicDynamicCommandProcessor.class)
public GenericGraphEventFactory genericGraphEventFactory(
List<SpecificGraphEventFactory> specificGraphEventFactories
) {
return new GenericGraphEventFactory(specificGraphEventFactories);
}
@Bean
@ConditionalOnBean(BasicDynamicCommandProcessor.class)
public GenericCommandEventGraphMappingProvider genericCommandEventGraphMappingProvider(
List<SpecificCommandEventGraphMappingProvider> specificCommandEventGraphMappingProviders
) {
return new GenericCommandEventGraphMappingProvider(specificCommandEventGraphMappingProviders);
}
@Bean
@ConditionalOnBean(GenericDynamicCommandProcessor.class)
public DynamicAggregateCommandProcessor dynamicAggregateCommandProcessor(
AggregateDefinitionProvider aggregateDefinitionProvider,
GenericAggregateGraphStateModificator genericAggregateGraphStateModificator
) {
return new DynamicAggregateCommandProcessor(
aggregateDefinitionProvider,
genericAggregateGraphStateModificator
);
}
@Bean
@ConditionalOnBean(DynamicAggregateCommandProcessor.class)
public GenericAggregateGraphStateModificator genericAggregateGraphStateModificator(
List<AggregateGraphStateModificator> aggregateGraphStateModificators,
OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper
) {
return new GenericAggregateGraphStateModificator(
aggregateGraphStateModificators,
operationDefinitionStructureTypeMapper
);
}
@Bean
public EventFactoryModificationTraverser eventFactoryModificationTraverser() {
return new EventFactoryModificationTraverser();
}
@Bean
public EventModificatorOgmProvider eventModificatorOgmProvider(
StructureSchemaFinder structureSchemaFinder,
DynamicOgmProvider dynamicOgmProvider
) {
return new EventModificatorOgmProvider(structureSchemaFinder, dynamicOgmProvider);
}
@Bean
@ConditionalOnBean(GenericAggregateGraphStateModificator.class)
public AddAggregateGraphStateModificator addAggregateGraphStateModificator(
GenericObjectGraphMapper objectGraphMapper,
EventFactoryModificationTraverser eventFactoryModificationTraverser,
EventModificatorOgmProvider eventModificatorOgmProvider
) {
return new AddAggregateGraphStateModificator(
objectGraphMapper,
eventFactoryModificationTraverser,
eventModificatorOgmProvider
);
}
@Bean
@ConditionalOnBean(GenericAggregateGraphStateModificator.class)
public UpsertAggregateGraphStateModificator upsertAggregateGraphStateModificator(
GenericObjectGraphMapper objectGraphMapper,
EventFactoryModificationTraverser eventFactoryModificationTraverser,
EventModificatorOgmProvider eventModificatorOgmProvider
) {
return new UpsertAggregateGraphStateModificator(
objectGraphMapper,
eventFactoryModificationTraverser,
eventModificatorOgmProvider
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/FixtureGeneratorConfiguration.java | package ai.stapi.graphsystem.configuration;
import ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator.FixtureCommandsGenerator;
import ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator.GenericFixtureCommandsGenerator;
import java.util.List;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class FixtureGeneratorConfiguration {
@Bean
public GenericFixtureCommandsGenerator genericFixtureCommandsGenerator(
List<FixtureCommandsGenerator> fixtureCommandsGenerators
) {
return new GenericFixtureCommandsGenerator(fixtureCommandsGenerators);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/OperationDefinitionConfiguration.java | package ai.stapi.graphsystem.configuration;
import ai.stapi.graphsystem.operationdefinition.infrastructure.AdHocOperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionStructureTypeMapper;
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.adHocLoaders.GenericAdHocModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaFinder;
import ai.stapi.schema.structureSchemaProvider.StructureSchemaProvider;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class OperationDefinitionConfiguration {
@Bean
@ConditionalOnMissingBean(OperationDefinitionProvider.class)
public AdHocOperationDefinitionProvider adHocOperationDefinitionProvider(
GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader,
ScopeCacher scopeCacher
) {
return new AdHocOperationDefinitionProvider(
genericAdHocModelDefinitionsLoader,
scopeCacher
);
}
@Bean
public OperationDefinitionStructureTypeMapper operationDefinitionStructureTypeMapper(
StructureSchemaProvider structureSchemaProvider
) {
return new OperationDefinitionStructureTypeMapper(structureSchemaProvider);
}
@Bean
public AddItemOnResourceOperationsMapper addItemOnResourceOperationsMapper(
StructureSchemaFinder structureSchemaFinder
) {
return new AddItemOnResourceOperationsMapper(structureSchemaFinder);
}
@Bean
public CreationalResourceOperationMapper creationalResourceOperationMapper(
StructureSchemaFinder structureSchemaFinder
) {
return new CreationalResourceOperationMapper(structureSchemaFinder);
}
@Bean
public UpdateResourceOperationMapper updateResourceOperationMapper(
StructureSchemaFinder structureSchemaFinder
) {
return new UpdateResourceOperationMapper(structureSchemaFinder);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/SerializationConfiguration.java | package ai.stapi.graphsystem.configuration;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class SerializationConfiguration {
@Bean
@ConditionalOnBean
public ObjectMapper lenientObjectMapper(ObjectMapper objectMapper) {
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
return objectMapper;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/StructureDefinitionConfiguration.java | package ai.stapi.graphsystem.configuration;
import ai.stapi.graphoperations.ogmProviders.GenericGraphMappingProvider;
import ai.stapi.graphsystem.genericGraphEventFactory.GenericGraphEventFactory;
import ai.stapi.graphsystem.structuredefinition.classnameprovider.StructureDefinitionClassNameProvider;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.ImportStructureDefinitionOgmProvider;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.StructureDefinitionImportedGraphEventFactory;
import ai.stapi.graphsystem.structuredefinition.identificatorProvider.ElementDefinitionIdentificatorProvider;
import ai.stapi.graphsystem.structuredefinition.identificatorProvider.StructureDefinitionDifferentialIdentificatorProvider;
import ai.stapi.graphsystem.structuredefinition.loader.SystemAdHocStructureDefinitionLoader;
import ai.stapi.schema.adHocLoaders.GenericAdHocModelDefinitionsLoader;
import ai.stapi.schema.scopeProvider.ScopeCacher;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import com.fasterxml.jackson.databind.ObjectMapper;
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;
@AutoConfiguration
public class StructureDefinitionConfiguration {
@Bean
@ConditionalOnMissingBean(StructureDefinitionLoader.class)
public SystemAdHocStructureDefinitionLoader systemAdHocStructureDefinitionLoader(
GenericAdHocModelDefinitionsLoader genericAdHocModelDefinitionsLoader,
ObjectMapper objectMapper,
ScopeCacher scopeCacher
) {
return new SystemAdHocStructureDefinitionLoader(
genericAdHocModelDefinitionsLoader,
objectMapper,
scopeCacher
);
}
@Bean
public ElementDefinitionIdentificatorProvider elementDefinitionIdentificatorProvider() {
return new ElementDefinitionIdentificatorProvider();
}
@Bean
public StructureDefinitionDifferentialIdentificatorProvider structureDefinitionDifferentialIdentificatorProvider() {
return new StructureDefinitionDifferentialIdentificatorProvider();
}
@Bean
public ImportStructureDefinitionOgmProvider importStructureDefinitionOgmProvider(
GenericGraphMappingProvider genericGraphMappingProvider
) {
return new ImportStructureDefinitionOgmProvider(genericGraphMappingProvider);
}
@Bean
@ConditionalOnBean(GenericGraphEventFactory.class)
public StructureDefinitionImportedGraphEventFactory structureDefinitionImportedGraphEventFactory() {
return new StructureDefinitionImportedGraphEventFactory();
}
@Bean
public StructureDefinitionClassNameProvider structureDefinitionClassNameProvider() {
return new StructureDefinitionClassNameProvider();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/configuration/SystemConfiguration.java | package ai.stapi.graphsystem.configuration;
import ai.stapi.graphsystem.systemfixtures.model.SystemModelDefinitionsLoader;
import ai.stapi.graphsystem.systemfixtures.model.SystemModelFixtureGenerator;
import ai.stapi.schema.adHocLoaders.FileLoader;
import ai.stapi.schema.scopeProvider.ScopeOptions;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.context.annotation.Bean;
@AutoConfiguration
public class SystemConfiguration {
@Bean
public ScopeOptions systemScopeOptions() {
return new ScopeOptions(
SystemModelDefinitionsLoader.SCOPE,
SystemModelDefinitionsLoader.TAG
);
}
@Bean
public SystemModelDefinitionsLoader systemModelDefinitionsLoader(
FileLoader fileLoader
) {
return new SystemModelDefinitionsLoader(fileLoader);
}
@Bean
public SystemModelFixtureGenerator systemModelFixtureGenerator(
FileLoader fileLoader
) {
return new SystemModelFixtureGenerator(fileLoader);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/dynamiccommandprocessor/BasicDynamicCommandProcessor.java | package ai.stapi.graphsystem.dynamiccommandprocessor;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graphsystem.genericGraphEventFactory.GenericGraphEventFactory;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphMapper.model.GenericObjectGraphMapper;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphsystem.commandEventGraphMappingProvider.GenericCommandEventGraphMappingProvider;
import java.util.List;
public class BasicDynamicCommandProcessor implements SpecificDynamicCommandProcessor {
protected final GenericObjectGraphMapper objectGraphMapper;
protected final GenericGraphEventFactory genericEventFactory;
protected final GenericCommandEventGraphMappingProvider commandEventGraphMappingProvider;
public BasicDynamicCommandProcessor(
GenericObjectGraphMapper objectGraphMapper,
GenericGraphEventFactory genericEventFactory,
GenericCommandEventGraphMappingProvider commandEventGraphMappingProvider
) {
this.objectGraphMapper = objectGraphMapper;
this.genericEventFactory = genericEventFactory;
this.commandEventGraphMappingProvider = commandEventGraphMappingProvider;
}
@Override
public List<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> processCommand(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var eventMappings = this.commandEventGraphMappingProvider.provideGraphMappings(command);
return eventMappings.entrySet().stream()
.map(entry -> {
var result = this.objectGraphMapper.mapToGraph(
entry.getValue(),
command,
missingFieldResolvingStrategy
);
return this.genericEventFactory.createEvent(
entry.getKey(),
command.getTargetIdentifier(),
result.getGraph(),
result.getElementForRemoval()
);
}).toList();
}
@Override
public boolean supports(AbstractCommand<? extends UniqueIdentifier> command) {
return this.commandEventGraphMappingProvider.containsFor(command);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/dynamiccommandprocessor/DynamicCommandProcessor.java | package ai.stapi.graphsystem.dynamiccommandprocessor;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import java.util.List;
public interface DynamicCommandProcessor {
default List<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> processCommand(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState
) {
return this.processCommand(command, currentAggregateState,
MissingFieldResolvingStrategy.STRICT);
}
List<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> processCommand(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/dynamiccommandprocessor/GenericDynamicCommandProcessor.java | package ai.stapi.graphsystem.dynamiccommandprocessor;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import java.util.List;
public class GenericDynamicCommandProcessor implements DynamicCommandProcessor {
private final List<SpecificDynamicCommandProcessor> specificDynamicCommandProcessors;
public GenericDynamicCommandProcessor(
List<SpecificDynamicCommandProcessor> specificDynamicCommandProcessors
) {
this.specificDynamicCommandProcessors = specificDynamicCommandProcessors;
}
@Override
public List<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> processCommand(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
) {
var supporting = this.getSupportingProcessor(command);
return supporting.processCommand(command, currentAggregateState, missingFieldResolvingStrategy);
}
private SpecificDynamicCommandProcessor getSupportingProcessor(
AbstractCommand<? extends UniqueIdentifier> command
) {
var supporting = this.specificDynamicCommandProcessors.stream()
.filter(specific -> specific.supports(command))
.toList();
if (supporting.size() != 1) {
throw new NoSupportingSpecificDynamicCommandProcessor(
String.format(
"Command cannot be processed, because there is no supporting command processor.%n" +
"Command type: '%s'" +
"Target aggregate identifier: '%s'",
command.getSerializationType(),
command.getTargetIdentifier()
)
);
}
return supporting.get(0);
}
private static class NoSupportingSpecificDynamicCommandProcessor extends RuntimeException {
public NoSupportingSpecificDynamicCommandProcessor(String message) {
super(message);
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/dynamiccommandprocessor/SpecificDynamicCommandProcessor.java | package ai.stapi.graphsystem.dynamiccommandprocessor;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.graphsystem.messaging.command.AbstractCommand;
import ai.stapi.graphoperations.objectGraphMapper.model.MissingFieldResolvingStrategy;
import java.util.List;
public interface SpecificDynamicCommandProcessor {
default List<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> processCommand(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState
) {
return this.processCommand(
command,
currentAggregateState,
MissingFieldResolvingStrategy.STRICT
);
}
List<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> processCommand(
AbstractCommand<? extends UniqueIdentifier> command,
Graph currentAggregateState,
MissingFieldResolvingStrategy missingFieldResolvingStrategy
);
boolean supports(AbstractCommand<? extends UniqueIdentifier> command);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/eventdefinition/EventMessageDefinitionData.java | package ai.stapi.graphsystem.eventdefinition;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
public class EventMessageDefinitionData {
private String id;
private String name;
private StructureDefinitionId type;
private String description;
private EventMessageDefinitionData() {
}
public EventMessageDefinitionData(
String id,
String name,
StructureDefinitionId type,
String description
) {
this.id = id;
this.name = name;
this.type = type;
this.description = description;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public StructureDefinitionId getType() {
return type;
}
public String getDescription() {
return description;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/configuration/GenerateFixturesModuleConfiguration.java | package ai.stapi.graphsystem.fixtures.configuration;
import ai.stapi.graphsystem.aggregatedefinition.infrastructure.AdHocAggregateDefinitionProvider;
import ai.stapi.graphsystem.aggregatedefinition.model.AggregateDefinitionProvider;
import ai.stapi.graphsystem.structuredefinition.loader.SystemAdHocStructureDefinitionLoader;
import ai.stapi.schema.structuredefinition.loader.StructureDefinitionLoader;
import ai.stapi.graphsystem.operationdefinition.infrastructure.AdHocOperationDefinitionProvider;
import ai.stapi.graphsystem.operationdefinition.model.OperationDefinitionProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
@Configuration
@Profile("generate-fixtures")
public class GenerateFixturesModuleConfiguration {
@Bean
public StructureDefinitionLoader structureDefinitionLoader(
SystemAdHocStructureDefinitionLoader systemAdHocStructureDefinitionLoader
) {
return systemAdHocStructureDefinitionLoader;
}
@Bean
public OperationDefinitionProvider operationDefinitionProvider(
@Autowired AdHocOperationDefinitionProvider adHocOperationDefinitionProvider
) {
return adHocOperationDefinitionProvider;
}
@Bean
public AggregateDefinitionProvider aggregateDefinitionProvider(
@Autowired AdHocAggregateDefinitionProvider adHocAggregateDefinitionProvider
) {
return adHocAggregateDefinitionProvider;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/AbstractFixtureCommandsGenerator.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
public abstract class AbstractFixtureCommandsGenerator implements FixtureCommandsGenerator {
@Override
public String getGeneratorName() {
return this.getClass().getSimpleName();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/AbstractModelFileFixtureGenerator.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import ai.stapi.graphsystem.messaging.command.Command;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.ImportStructureDefinition;
import ai.stapi.schema.adHocLoaders.FileLoader;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;
public abstract class AbstractModelFileFixtureGenerator extends FileFixtureCommandsGenerator {
protected AbstractModelFileFixtureGenerator(
ObjectMapper objectMapper,
FileLoader fileLoader
) {
super(objectMapper, fileLoader);
}
private static boolean isKind(Command command, String filterType) {
if (command instanceof DynamicCommand dynamicCommand) {
return dynamicCommand.getData().get("kind").equals(filterType);
} else {
if (command instanceof ImportStructureDefinition importStructureDefinition) {
return importStructureDefinition.getStructureDefinitionSource()
.get("kind")
.equals(filterType);
}
return false;
}
}
@Override
protected List<Command> sortCommands(List<Command> list) {
var sortedList = new ArrayList<Command>();
var importStructuresCommand = list.stream()
.filter(ImportStructureDefinition.class::isInstance)
.map(ImportStructureDefinition.class::cast)
.toList();
sortedList.addAll(
importStructuresCommand.stream()
.filter(command -> AbstractModelFileFixtureGenerator.isKind(
command,
"primitive-type"
))
.toList()
);
sortedList.addAll(
importStructuresCommand.stream()
.filter(command -> AbstractModelFileFixtureGenerator.isKind(
command,
"complex-type"
))
.toList()
);
sortedList.addAll(
importStructuresCommand.stream()
.filter(command -> AbstractModelFileFixtureGenerator.isKind(
command,
"resource"
))
.toList()
);
var rest = list.stream()
.filter(command -> !(command instanceof ImportStructureDefinition))
.toList();
sortedList.addAll(rest);
return sortedList;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/CommandDefinition.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.messaging.command.Command;
import java.io.Serializable;
@JsonDeserialize(using = CommandDefinitionClassNameDeserializer.class)
public class CommandDefinition implements Serializable {
private Command command;
private String name;
private CommandDefinition() {
}
public CommandDefinition(Command command) {
this.command = command;
if (command instanceof DynamicCommand dynamicCommand) {
this.name = dynamicCommand.getSerializationType();
} else {
this.name = command.getClass().getName();
}
}
public Command getCommand() {
return command;
}
public String getName() {
return name;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/CommandDefinitionClassNameDeserializer.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import ai.stapi.graphsystem.messaging.command.Command;
import java.io.IOException;
public class CommandDefinitionClassNameDeserializer extends StdDeserializer<CommandDefinition> {
public CommandDefinitionClassNameDeserializer() {
this(null);
}
protected CommandDefinitionClassNameDeserializer(Class<?> vc) {
super(vc);
}
@Override
public CommandDefinition deserialize(
JsonParser jsonParser,
DeserializationContext deserializationContext
) throws IOException, JsonProcessingException {
JsonNode node = jsonParser.getCodec().readTree(jsonParser);
var commandClassName = node.get("name").asText();
try {
var commandClazz = Class.forName(commandClassName);
var serializedCommand = node.get("command").toString();
var command = (Command) new ObjectMapper().readValue(serializedCommand, commandClazz);
return new CommandDefinition(command);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/FileFixtureCommandsGenerator.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import ai.stapi.graphsystem.messaging.command.Command;
import ai.stapi.graphsystem.messaging.command.DynamicCommand;
import ai.stapi.graphsystem.structuredefinition.command.importStructureDefinitionFromSource.ImportStructureDefinition;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.schema.adHocLoaders.FileLoader;
import ai.stapi.schema.structuredefinition.StructureDefinitionId;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import org.apache.commons.io.IOUtils;
import org.jetbrains.annotations.Nullable;
import org.springframework.core.io.Resource;
public abstract class FileFixtureCommandsGenerator extends AbstractFixtureCommandsGenerator {
private final FileLoader fileLoader;
private final ObjectMapper objectMapper;
protected FileFixtureCommandsGenerator(
ObjectMapper objectMapper,
FileLoader fileLoader
) {
this.fileLoader = fileLoader;
this.objectMapper = objectMapper;
}
@Nullable
private static FixtureFileInfo getFixtureFileInfo(Resource resource) throws IOException {
String fileUri = resource.getURI().toString();
String[] parts = fileUri.split("/");
if (parts.length < 2) {
return null;
}
String commandName = parts[parts.length - 2];
String filename = commandName + "/" + parts[parts.length - 1];
return new FixtureFileInfo(filename, commandName);
}
@Override
public FixtureCommandsGeneratorResult generate(Set<String> alreadyProcessedFileNames) {
return new FixtureCommandsGeneratorResult(
this.getClass(),
this.loadCommandsFromFiles(alreadyProcessedFileNames),
alreadyProcessedFileNames
);
}
protected List<Command> loadCommandsFromFiles(Set<String> processedFileNames) {
var list = this.fileLoader.loadFixtureFiles(
this.getClass(),
processedFileNames
).stream()
.sorted(Comparator.comparing(Resource::getFilename))
.map(this::mapJsonFileToCommand)
.toList();
return this.sortCommands(list);
}
protected List<Command> sortCommands(List<Command> loadCommandsFromFiles) {
return new ArrayList<>(loadCommandsFromFiles);
}
protected Command mapJsonFileToCommand(Resource resource) {
byte[] content;
try {
InputStream input = resource.getInputStream();
content = IOUtils.toByteArray(input);
} catch (IOException exception) {
try {
throw new RuntimeException(
String.format(
"Unable to read resource file of URI %s",
resource.getURI()
),
exception
);
} catch (IOException ex) {
throw new RuntimeException(
"Unable to read resource file and not even its URI.",
exception
);
}
}
try {
var commandJsonPayload = this.objectMapper.readValue(
content,
LinkedHashMap.class
);
var fileInfo = getFixtureFileInfo(resource);
Command command;
/*
TODO : this if for structure definition should vanish when we will have properly dynamic
aggregates including this one
*/
if (Objects.requireNonNull(fileInfo).commandType.equals("ImportStructureDefinition")) {
command = new ImportStructureDefinition(
new StructureDefinitionId(
(String) commandJsonPayload.get("id")
),
commandJsonPayload
);
} else {
command = new DynamicCommand(
new UniqueIdentifier((String) commandJsonPayload.get("id")),
fileInfo.getCommandType(),
commandJsonPayload
);
}
return command;
} catch (IOException exception) {
try {
throw new RuntimeException(
String.format(
"Unable to deserialize bytecode content of resource file of URI: %s",
resource.getURI()
),
exception
);
} catch (IOException ex) {
throw new RuntimeException(
"Unable to read resource file and not even determine its URI.",
exception
);
}
}
}
private static class FixtureFileInfo {
private final String fullName;
private final String commandType;
public FixtureFileInfo(String fullName, String commandType) {
this.fullName = fullName;
this.commandType = commandType;
}
public String getFullName() {
return fullName;
}
public String getCommandType() {
return commandType;
}
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/FixtureCommandsGenerator.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import java.util.List;
import java.util.Set;
public interface FixtureCommandsGenerator {
float PRIORITY_STRUCTURES = 1000;
float PRIORITY_DATA = 100;
List<String> getFixtureTags();
String getGeneratorName();
FixtureCommandsGeneratorResult generate(Set<String> processedFileNames);
float getPriority();
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/FixtureCommandsGeneratorResult.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import ai.stapi.graphsystem.messaging.command.Command;
import java.io.Serializable;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class FixtureCommandsGeneratorResult implements Serializable {
private String generatorClassName;
private List<CommandDefinition> commandDefinitions;
private boolean oneTimeGenerator = false;
private Set<String> processedFiles;
private FixtureCommandsGeneratorResult() {
}
public FixtureCommandsGeneratorResult(
Class<? extends FixtureCommandsGenerator> generatorClassName,
List<Command> commands
) {
this.generatorClassName = generatorClassName.getName();
this.commandDefinitions =
commands.stream().map(CommandDefinition::new).collect(Collectors.toList());
this.processedFiles = new HashSet<>();
this.oneTimeGenerator = true;
}
public FixtureCommandsGeneratorResult(
Class<? extends FixtureCommandsGenerator> generatorClassName,
List<Command> commands,
Set<String> processedFiles
) {
this.generatorClassName = generatorClassName.getName();
this.commandDefinitions =
commands.stream().map(CommandDefinition::new).collect(Collectors.toList());
this.processedFiles = processedFiles;
this.oneTimeGenerator = false;
}
public String getGeneratorClassName() {
return generatorClassName;
}
@JsonIgnore
public List<Command> getCommands() {
return commandDefinitions.stream().map(CommandDefinition::getCommand)
.collect(Collectors.toList());
}
public List<CommandDefinition> getCommandDefinitions() {
return commandDefinitions;
}
public boolean isOneTimeGenerator() {
return oneTimeGenerator;
}
public Set<String> getProcessedFiles() {
return this.processedFiles;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/GenericFixtureCommandsGenerator.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.stream.Stream;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
public class GenericFixtureCommandsGenerator {
private final List<FixtureCommandsGenerator> fixtureCommandsGenerators;
@Autowired
public GenericFixtureCommandsGenerator(List<FixtureCommandsGenerator> fixtureCommandsGenerators) {
this.fixtureCommandsGenerators = fixtureCommandsGenerators;
}
public Stream<FixtureCommandsGeneratorResult> generate(
List<String> tags,
List<String> processedGenerators,
Set<String> processedFileNames,
float minPriority,
float maxPriority
) {
var fixtureCommandResults = this.fixtureCommandsGenerators.stream()
.filter(fixtureCommandsGenerator ->
fixtureCommandsGenerator.getPriority() >= minPriority
&& fixtureCommandsGenerator.getPriority() <= maxPriority
)
.sorted(Comparator.comparingDouble(FixtureCommandsGenerator::getPriority).reversed())
.filter((generator) -> generator.getFixtureTags().stream().anyMatch(tags::contains)
&& !processedGenerators.contains(generator.getGeneratorName()))
.map(fixtureCommandsGenerator -> fixtureCommandsGenerator.generate(processedFileNames))
.toList();
return fixtureCommandResults.stream();
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/fixtures/fixtureCommandsGenerator/SimpleFixtureCommandsGenerator.java | package ai.stapi.graphsystem.fixtures.fixtureCommandsGenerator;
import ai.stapi.graphsystem.messaging.command.Command;
import java.util.List;
import java.util.Set;
public abstract class SimpleFixtureCommandsGenerator extends AbstractFixtureCommandsGenerator {
protected abstract List<Command> getCommands();
@Override
public FixtureCommandsGeneratorResult generate(Set<String> processedFileNames) {
return new FixtureCommandsGeneratorResult(
this.getClass(),
this.getCommands()
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/genericGraphEventFactory/GenericGraphEventFactory.java | package ai.stapi.graphsystem.genericGraphEventFactory;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graphsystem.genericGraphEventFactory.exception.GenericGraphEventFactoryException;
import ai.stapi.graphsystem.genericGraphEventFactory.specific.SpecificGraphEventFactory;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.Graph;
import ai.stapi.graphsystem.messaging.event.DynamicGraphUpdatedEvent;
import ai.stapi.identity.UniqueIdentifier;
import java.util.List;
import org.jetbrains.annotations.NotNull;
public class GenericGraphEventFactory {
private final List<SpecificGraphEventFactory> eventFactories;
public GenericGraphEventFactory(
List<SpecificGraphEventFactory> eventFactories
) {
this.eventFactories = eventFactories;
}
public AggregateGraphUpdatedEvent<? extends UniqueIdentifier> createEvent(
Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> eventType,
String eventName,
UniqueIdentifier identity,
Graph graph,
List<GraphElementForRemoval> elementsForRemoval
) {
if (DynamicGraphUpdatedEvent.class.equals(eventType)) {
return new DynamicGraphUpdatedEvent(
eventName,
identity,
graph,
elementsForRemoval
);
}
var supportingFactory = this.getSupportingSpecificFactory(eventType);
return supportingFactory.createEvent(identity, graph, elementsForRemoval);
}
public AggregateGraphUpdatedEvent<? extends UniqueIdentifier> createEvent(
Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> eventType,
UniqueIdentifier identity,
Graph graph,
List<GraphElementForRemoval> elementsForRemoval
) {
return this.createEvent(
eventType,
eventType.getSimpleName(),
identity,
graph,
elementsForRemoval
);
}
@NotNull
private SpecificGraphEventFactory getSupportingSpecificFactory(
Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> event
) {
var supportingFactories = this.eventFactories.stream()
.filter(specificObjectGraphMapper -> specificObjectGraphMapper.supports(event))
.toList();
if (supportingFactories.isEmpty()) {
throw GenericGraphEventFactoryException.becauseNoSupportingSpecificFactoriesForGivenEvent(event);
}
if (supportingFactories.size() > 1) {
throw GenericGraphEventFactoryException.becauseMoreThanOneSpecificFactoriesForGivenCommand(event);
}
return supportingFactories.get(0);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/genericGraphEventFactory | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/genericGraphEventFactory/exception/GenericGraphEventFactoryException.java | package ai.stapi.graphsystem.genericGraphEventFactory.exception;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
public class GenericGraphEventFactoryException extends RuntimeException {
private GenericGraphEventFactoryException(String message) {
super(message);
}
public static GenericGraphEventFactoryException becauseNoSupportingSpecificFactoriesForGivenEvent(
Class<? extends AggregateGraphUpdatedEvent> event
) {
return new GenericGraphEventFactoryException(
"There are no supporting factories for event '" + event.getSimpleName() + "'."
);
}
public static GenericGraphEventFactoryException becauseMoreThanOneSpecificFactoriesForGivenCommand(
Class<? extends AggregateGraphUpdatedEvent> event) {
return new GenericGraphEventFactoryException(
"There are multiple supporting factories for event '"
+ event.getSimpleName()
+ "' and that is not allowed."
);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/genericGraphEventFactory | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/genericGraphEventFactory/specific/SpecificGraphEventFactory.java | package ai.stapi.graphsystem.genericGraphEventFactory.specific;
import ai.stapi.graphsystem.messaging.event.AggregateGraphUpdatedEvent;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import java.util.List;
public interface SpecificGraphEventFactory {
AggregateGraphUpdatedEvent<? extends UniqueIdentifier> createEvent(
UniqueIdentifier identity,
Graph graph,
List<GraphElementForRemoval> elementsForRemoval
);
boolean supports(
Class<? extends AggregateGraphUpdatedEvent<? extends UniqueIdentifier>> event);
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/command/AbstractCommand.java | package ai.stapi.graphsystem.messaging.command;
import ai.stapi.serialization.AbstractSerializableObject;
import ai.stapi.identity.UniqueIdentifier;
public abstract class AbstractCommand<T extends UniqueIdentifier> extends AbstractSerializableObject
implements EndpointCommand {
private T targetIdentifier;
protected AbstractCommand() {
}
protected AbstractCommand(
T targetIdentifier,
String serializationType
) {
super(serializationType);
this.targetIdentifier = targetIdentifier;
}
public T getTargetIdentifier() {
return targetIdentifier;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/command/AbstractPayloadCommand.java | package ai.stapi.graphsystem.messaging.command;
import ai.stapi.identity.UniqueIdentifier;
import java.util.HashMap;
import java.util.Map;
public abstract class AbstractPayloadCommand<T extends UniqueIdentifier>
extends AbstractCommand<T> {
private Map<String, Object> data;
protected AbstractPayloadCommand() {
super();
}
protected AbstractPayloadCommand(
String serializationType,
T uniqueIdentifier,
Map<String, Object> definition
) {
super(
uniqueIdentifier,
serializationType
);
this.data = new HashMap<>(definition);
}
public Map<String, Object> getData() {
return data;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/command/Command.java | package ai.stapi.graphsystem.messaging.command;
import ai.stapi.identity.UniqueIdentifier;
import ai.stapi.serialization.SerializableObject;
public interface Command extends SerializableObject {
UniqueIdentifier getTargetIdentifier();
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/command/DynamicCommand.java | package ai.stapi.graphsystem.messaging.command;
import ai.stapi.identity.UniqueIdentifier;
import java.util.Map;
public class DynamicCommand extends AbstractPayloadCommand<UniqueIdentifier> {
public static final String SERIALIZATION_TYPE_FIELD_NAME = "serializationType";
public static final String TARGET_IDENTIFIER_FIELD_NAME = "targetIdentifier";
private DynamicCommand() {
}
public DynamicCommand(
UniqueIdentifier targetIdentifier,
String serializationType,
Map<String, Object> data
) {
super(serializationType, targetIdentifier, data);
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/command/EndpointCommand.java | package ai.stapi.graphsystem.messaging.command;
public interface EndpointCommand extends Command {
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/event/AggregateGraphUpdatedEvent.java | package ai.stapi.graphsystem.messaging.event;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import java.util.List;
public abstract class AggregateGraphUpdatedEvent<T extends UniqueIdentifier> extends GraphUpdatedEvent {
private T identity;
protected AggregateGraphUpdatedEvent() {
}
protected AggregateGraphUpdatedEvent(
T identity,
List<GraphElementForRemoval> graphElementsForRemoval
) {
super(graphElementsForRemoval);
this.identity = identity;
}
protected AggregateGraphUpdatedEvent(
T identity,
Graph synchronizedGraph
) {
super(synchronizedGraph);
this.identity = identity;
}
protected AggregateGraphUpdatedEvent(
T identity,
Graph synchronizedGraph,
List<GraphElementForRemoval> graphElementsForRemoval
) {
super(synchronizedGraph, graphElementsForRemoval);
this.identity = identity;
}
public T getIdentity() {
return identity;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/event/DynamicGraphUpdatedEvent.java | package ai.stapi.graphsystem.messaging.event;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.Graph;
import ai.stapi.identity.UniqueIdentifier;
import java.util.List;
public class DynamicGraphUpdatedEvent extends AggregateGraphUpdatedEvent<UniqueIdentifier> {
private String eventName;
private DynamicGraphUpdatedEvent() {
}
public DynamicGraphUpdatedEvent(
String eventName,
UniqueIdentifier identity,
List<GraphElementForRemoval> graphElementsForRemoval
) {
super(identity, graphElementsForRemoval);
this.eventName = eventName;
}
public DynamicGraphUpdatedEvent(
String eventName,
UniqueIdentifier identity,
Graph synchronizedGraph
) {
super(identity, synchronizedGraph);
this.eventName = eventName;
}
public DynamicGraphUpdatedEvent(
String eventName,
UniqueIdentifier identity,
Graph synchronizedGraph,
List<GraphElementForRemoval> graphElementsForRemoval
) {
super(identity, synchronizedGraph, graphElementsForRemoval);
this.eventName = eventName;
}
public String getEventName() {
return eventName;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/event/Event.java | package ai.stapi.graphsystem.messaging.event;
public interface Event {
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/event/GraphUpdatedEvent.java | package ai.stapi.graphsystem.messaging.event;
import ai.stapi.graph.graphElementForRemoval.GraphElementForRemoval;
import ai.stapi.graph.Graph;
import ai.stapi.graphsystem.messaging.event.Event;
import java.util.ArrayList;
import java.util.List;
public abstract class GraphUpdatedEvent implements Event {
private Graph synchronizedGraph;
private List<GraphElementForRemoval> graphElementsForRemoval;
protected GraphUpdatedEvent() {
}
protected GraphUpdatedEvent(List<GraphElementForRemoval> graphElementsForRemoval) {
this.graphElementsForRemoval = graphElementsForRemoval;
this.synchronizedGraph = new Graph();
}
protected GraphUpdatedEvent(Graph synchronizedGraph) {
this.synchronizedGraph = synchronizedGraph;
this.graphElementsForRemoval = new ArrayList<>();
}
protected GraphUpdatedEvent(
Graph synchronizedGraph,
List<GraphElementForRemoval> graphElementsForRemoval
) {
this.synchronizedGraph = synchronizedGraph;
this.graphElementsForRemoval = graphElementsForRemoval;
}
public Graph getSynchronizedGraph() {
return synchronizedGraph;
}
public List<GraphElementForRemoval> getGraphElementsForRemoval() {
return graphElementsForRemoval;
}
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/query/Query.java | package ai.stapi.graphsystem.messaging.query;
public interface Query {
}
|
0 | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging | java-sources/ai/stapi/graph-system/0.3.2/ai/stapi/graphsystem/messaging/query/Response.java | package ai.stapi.graphsystem.messaging.query;
public interface Response {
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.