CQRS 4.5 - TransitAnalyzer - implementacja grafu

Author: pilloPl

pom.xml

@@ -7,6 +7,7 @@
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.4.4</version>
+
         <relativePath/> <!-- lookup parent from repository -->
     </parent>
     <groupId>io.refactorers</groupId>
@@ -48,6 +49,31 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.neo4j.driver</groupId>
+            <artifactId>neo4j-java-driver</artifactId>
+            <version>4.4.3</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-embedded-driver</artifactId>
+            <version>3.2.28</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-test</artifactId>
+            <version>3.1.22</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>3.0.0</version>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.togglz</groupId>
             <artifactId>togglz-junit5</artifactId>

src/main/java/io/legacyfighter/cabs/config/Neo4jConfig.java

@@ -0,0 +1,28 @@
+package io.legacyfighter.cabs.config;
+
+import io.legacyfighter.cabs.transitanalyzer.GraphTransitAnalyzer;
+import org.neo4j.graphdb.GraphDatabaseService;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+
+@Configuration
+class Neo4jConfig {
+
+    @Value("${neo4j.db.file:testPath}")
+    private String dbPath;
+
+    @Bean(destroyMethod = "onClose")
+    GraphTransitAnalyzer graphTransitAnalyzer()  {
+        return new GraphTransitAnalyzer(notConnectedOnProdYet(dbPath));
+    }
+
+    @Bean
+    GraphDatabaseService notConnectedOnProdYet(String dbPath) {
+        return null;
+    }
+
+
+}
+

src/main/java/io/legacyfighter/cabs/transitanalyzer/GraphTransitAnalyzer.java

@@ -0,0 +1,55 @@
+package io.legacyfighter.cabs.transitanalyzer;
+
+
+import org.neo4j.graphdb.*;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.stream.Collectors;
+
+
+public class GraphTransitAnalyzer {
+
+    private final GraphDatabaseService graphDb;
+
+    public GraphTransitAnalyzer(GraphDatabaseService graphDatabaseService) {
+        this.graphDb = graphDatabaseService;
+    }
+
+    public List<Long> analyze(Long clientId, Integer addressHash) {
+        try (Transaction t = graphDb.beginTx()) {
+            Result result = graphDb.execute("MATCH p=(a:Address)-[:Transit*]->(:Address) " +
+                    "WHERE a.hash = " + addressHash + " " +
+                    "AND (ALL(x IN range(1, length(p)-1) WHERE ((relationships(p)[x]).clientId = " + clientId + ") AND 0 <= duration.inSeconds( (relationships(p)[x-1]).completeAt, (relationships(p)[x]).started).minutes <= 15)) " +
+                    "AND length(p) >= 1 " +
+                    "RETURN [x in nodes(p) | x.hash] AS hashes ORDER BY length(p) DESC LIMIT 1");
+
+            t.success();
+
+            return ((List<Long>) result.next().get("hashes")).stream().collect(Collectors.toList());
+        }
+    }
+
+    public void addTransitBetweenAddresses(Long clientId, Long transitId, Integer addressFromHash, Integer addressToHash, Instant started, Instant completeAt) {
+        DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME.withZone(ZoneId.systemDefault());
+
+        try (Transaction t = graphDb.beginTx()) {
+            graphDb.execute("MERGE (from:Address {hash: " + addressFromHash + "})");
+            graphDb.execute("MERGE (to:Address {hash: " + addressToHash + "})");
+            graphDb.execute("MATCH (from:Address {hash: " + addressFromHash + "}), (to:Address {hash: " + addressToHash + "}) " +
+                    "CREATE (from)-[:Transit {clientId: " + clientId + ", transitId: " + transitId + ", " +
+                    "started: datetime(\"" + formatter.format(started) + "\"), completeAt: datetime(\"" + formatter.format(completeAt) + "\") }]->(to)");
+
+            t.success();
+        }
+    }
+
+    public void onClose() {
+        if (graphDb != null) {
+            graphDb.shutdown();
+        }
+    }
+
+}

src/test/java/io/legacyfighter/cabs/common/TestWithGraphDB.java

@@ -0,0 +1,47 @@
+package io.legacyfighter.cabs.common;
+
+
+import io.legacyfighter.cabs.CabsApplication;
+import io.legacyfighter.cabs.transitanalyzer.GraphTransitAnalyzer;
+import org.neo4j.graphdb.GraphDatabaseService;
+import org.neo4j.graphdb.factory.GraphDatabaseFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Primary;
+import org.springframework.util.FileSystemUtils;
+
+import javax.annotation.PreDestroy;
+import java.io.File;
+
+
+@SpringBootTest(properties = "neo4j.db.file=${random.int}", classes = {CabsApplication.class, TestWithGraphDB.TestNeo4jConfig.class})
+public class TestWithGraphDB {
+
+    static class TestNeo4jConfig {
+
+        @Value("${neo4j.db.file}")
+        private String dbPath;
+
+        GraphDatabaseService testGraphDatabaseService() {
+            GraphDatabaseFactory graphDbFactory = new GraphDatabaseFactory();
+            FileSystemUtils.deleteRecursively(new File("db"));
+            File storeDir = new File("db/" + dbPath);
+            return graphDbFactory.newEmbeddedDatabase(storeDir);
+        }
+
+        @Bean(destroyMethod = "onClose")
+        @Primary
+        GraphTransitAnalyzer testGraphTransitAnalyzer()  {
+            return new GraphTransitAnalyzer(testGraphDatabaseService());
+        }
+
+        @PreDestroy
+        void cleanDbDir() {
+            FileSystemUtils.deleteRecursively(new File("db"));
+        }
+
+    }
+
+}
+

src/test/java/io/legacyfighter/cabs/integration/GraphTransitAnalyzerIntegrationTest.java

@@ -0,0 +1,35 @@
+package io.legacyfighter.cabs.integration;
+
+import io.legacyfighter.cabs.common.TestWithGraphDB;
+import io.legacyfighter.cabs.dto.AddressDTO;
+import io.legacyfighter.cabs.transitanalyzer.GraphTransitAnalyzer;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.time.Instant;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class GraphTransitAnalyzerIntegrationTest extends TestWithGraphDB {
+
+    @Autowired
+    GraphTransitAnalyzer analyzer;
+
+    @Test
+    void canRecognizeNewAddress() {
+        //given
+        analyzer.addTransitBetweenAddresses(1L, 1L, 111, 222, Instant.now(), Instant.now());
+        analyzer.addTransitBetweenAddresses(1L, 1L, 222, 333, Instant.now(), Instant.now());
+        analyzer.addTransitBetweenAddresses(1L, 1L, 333, 444, Instant.now(), Instant.now());
+
+        //when
+        List<Long> result = analyzer.analyze(1L, 111);
+
+        //then
+        assertThat(result).containsExactly(111L, 222L, 333L, 444L);
+
+    }
+
+}