CQRS 4.5 - TransitAnalyzer - podpięcie nowego modelu

Author: pilloPl

src/main/java/io/legacyfighter/cabs/common/Event.java

@@ -0,0 +1,4 @@
+package io.legacyfighter.cabs.common;
+
+public interface Event {
+}

src/main/java/io/legacyfighter/cabs/common/EventsPublisher.java

@@ -0,0 +1,18 @@
+package io.legacyfighter.cabs.common;
+
+
+import org.springframework.context.ApplicationEventPublisher;
+
+public class EventsPublisher {
+
+    private final ApplicationEventPublisher applicationEventPublisher;
+
+    public EventsPublisher(ApplicationEventPublisher applicationEventPublisher) {
+        this.applicationEventPublisher = applicationEventPublisher;
+    }
+
+    public void publish(Event event) {
+        applicationEventPublisher.publishEvent(event);
+    }
+}
+

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

@@ -0,0 +1,17 @@
+package io.legacyfighter.cabs.config;
+
+
+import io.legacyfighter.cabs.common.EventsPublisher;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+class EventPublisherConfiguration {
+
+    @Bean
+    EventsPublisher eventsPublisher(ApplicationEventPublisher applicationEventPublisher) {
+        return new EventsPublisher(applicationEventPublisher);
+    }
+}
+

src/main/java/io/legacyfighter/cabs/entity/events/TransitCompleted.java

@@ -0,0 +1,26 @@
+package io.legacyfighter.cabs.entity.events;
+
+import io.legacyfighter.cabs.common.Event;
+
+import java.time.Instant;
+
+public class TransitCompleted implements Event {
+
+    public final Long clientId;
+    public final Long transitId;
+    public final Integer addressFromHash;
+    public final Integer addressToHash;
+    public final Instant started;
+    public final Instant completeAt;
+    public final Instant eventTimestamp;
+
+    public TransitCompleted(Long clientId, Long transitId, Integer addressFromHash, Integer addressToHash, Instant started, Instant completeAt, Instant eventTimestamp) {
+        this.clientId = clientId;
+        this.transitId = transitId;
+        this.addressFromHash = addressFromHash;
+        this.addressToHash = addressToHash;
+        this.started = started;
+        this.completeAt = completeAt;
+        this.eventTimestamp = eventTimestamp;
+    }
+}

src/main/java/io/legacyfighter/cabs/repository/AddressRepository.java

@@ -4,6 +4,7 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
 
 @Repository
 public class AddressRepository {
@@ -29,4 +30,13 @@ public Address save(Address address) {
     public Address getOne(Long id) {
         return addressRepositoryInterface.getOne(id);
     }
+
+    @Transactional
+    public Integer findHashById(Long addressId) {
+        return addressRepositoryInterface.findHashById(addressId);
+    }
+
+    public Address getByHash(int hash) {
+        return addressRepositoryInterface.findByHash(hash);
+    }
 }

src/main/java/io/legacyfighter/cabs/repository/AddressRepositoryInterface.java

@@ -5,4 +5,8 @@
 
 public interface AddressRepositoryInterface extends JpaRepository<Address, Long> {
     Address findByHash(Integer hash);
+
+    default Integer findHashById(Long id) {
+        return getOne(id).getHash();
+    }
 }

src/main/java/io/legacyfighter/cabs/service/TransitService.java

@@ -1,10 +1,12 @@
 package io.legacyfighter.cabs.service;
 
+import io.legacyfighter.cabs.common.EventsPublisher;
 import io.legacyfighter.cabs.distance.Distance;
 import io.legacyfighter.cabs.dto.AddressDTO;
 import io.legacyfighter.cabs.dto.DriverPositionDTOV2;
 import io.legacyfighter.cabs.dto.TransitDTO;
 import io.legacyfighter.cabs.entity.*;
+import io.legacyfighter.cabs.entity.events.TransitCompleted;
 import io.legacyfighter.cabs.money.Money;
 import io.legacyfighter.cabs.repository.*;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -63,6 +65,9 @@ public class TransitService {
     @Autowired
     private AwardsService awardsService;
 
+    @Autowired
+    private EventsPublisher eventsPublisher;
+
     @Transactional
     public Transit createTransit(TransitDTO transitDTO) {
         Address from = addressFromDto(transitDTO.getFrom());
@@ -417,6 +422,10 @@ public void completeTransit(Long driverId, Long transitId, Address destinationAd
         awardsService.registerMiles(transit.getClient().getId(), transitId);
         transitRepository.save(transit);
         invoiceGenerator.generate(transit.getPrice().toInt(), transit.getClient().getName() + " " + transit.getClient().getLastName());
+        eventsPublisher.publish(new TransitCompleted(
+                transit.getClient().getId(), transitId, transit.getFrom().getHash(), transit.getTo().getHash(), transit.getStarted(), transit.getCompleteAt(), Instant.now(clock))
+        );
+
     }
 
     @Transactional

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

@@ -1,7 +1,9 @@
 package io.legacyfighter.cabs.transitanalyzer;
 
 
+import io.legacyfighter.cabs.entity.events.TransitCompleted;
 import org.neo4j.graphdb.*;
+import org.springframework.transaction.event.TransactionalEventListener;
 
 import java.time.Instant;
 import java.time.ZoneId;
@@ -46,6 +48,11 @@ public void addTransitBetweenAddresses(Long clientId, Long transitId, Integer ad
         }
     }
 
+    @TransactionalEventListener
+    public void handle(TransitCompleted transitCompleted) {
+        addTransitBetweenAddresses(transitCompleted.clientId, transitCompleted.transitId, transitCompleted.addressFromHash, transitCompleted.addressToHash, transitCompleted.started, transitCompleted.completeAt);
+    }
+
     public void onClose() {
         if (graphDb != null) {
             graphDb.shutdown();

src/main/java/io/legacyfighter/cabs/ui/TransitAnalyzerController.java

@@ -2,9 +2,8 @@
 
 import io.legacyfighter.cabs.dto.AddressDTO;
 import io.legacyfighter.cabs.dto.AnalyzedAddressesDTO;
-import io.legacyfighter.cabs.entity.Address;
-import io.legacyfighter.cabs.service.TransitAnalyzer;
-import org.springframework.beans.factory.annotation.Autowired;
+import io.legacyfighter.cabs.repository.AddressRepository;
+import io.legacyfighter.cabs.transitanalyzer.GraphTransitAnalyzer;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RestController;
@@ -14,17 +13,27 @@
 
 @RestController
 public class TransitAnalyzerController {
-    @Autowired
-    TransitAnalyzer transitAnalyzer;
+
+    private final GraphTransitAnalyzer graphTransitAnalyzer;
+    private final AddressRepository addressRepository;
+
+    public TransitAnalyzerController(GraphTransitAnalyzer graphTransitAnalyzer, AddressRepository addressRepository) {
+        this.graphTransitAnalyzer = graphTransitAnalyzer;
+        this.addressRepository = addressRepository;
+    }
 
     @GetMapping("/transitAnalyze/{clientId}/{addressId}")
     public AnalyzedAddressesDTO analyze(@PathVariable Long clientId, @PathVariable Long addressId) {
-        List<Address> addresses = transitAnalyzer.analyze(clientId, addressId);
-        List<AddressDTO> addressDTOs = addresses
+        List<Long> hashes = graphTransitAnalyzer.analyze(clientId, addressRepository.findHashById(addressId));
+        List<AddressDTO> addressDTOs = hashes
                 .stream()
-                .map(a -> new AddressDTO(a))
+                .map(this::mapToAddressDTO)
                 .collect(Collectors.toList());
 
         return new AnalyzedAddressesDTO(addressDTOs);
     }
+
+    private AddressDTO mapToAddressDTO(Long hash) {
+        return new AddressDTO(addressRepository.getByHash(hash.intValue()));
+    }
 }

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

@@ -1,30 +1,37 @@
 package io.legacyfighter.cabs.integration;
 
 import io.legacyfighter.cabs.common.Fixtures;
+import io.legacyfighter.cabs.common.TestWithGraphDB;
 import io.legacyfighter.cabs.dto.AddressDTO;
 import io.legacyfighter.cabs.dto.AnalyzedAddressesDTO;
 import io.legacyfighter.cabs.entity.Address;
 import io.legacyfighter.cabs.entity.Client;
 import io.legacyfighter.cabs.entity.Driver;
 import io.legacyfighter.cabs.service.GeocodingService;
 import io.legacyfighter.cabs.ui.TransitAnalyzerController;
+import org.awaitility.Awaitility;
+import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
 
 import java.time.Clock;
+import java.util.Arrays;
+import java.util.List;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static io.legacyfighter.cabs.entity.CarType.CarClass.VAN;
 import static java.time.LocalDateTime.of;
 import static java.time.ZoneOffset.UTC;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.*;
+import static org.awaitility.Awaitility.await;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
 
-@SpringBootTest
-public class AnalyzeNearbyTransitsIntegrationTest {
+public class AnalyzeNearbyTransitsIntegrationTest extends TestWithGraphDB {
 
     @Autowired
     Fixtures fixtures;
@@ -77,11 +84,10 @@ void canFindLongestTravel() {
         //when
         AnalyzedAddressesDTO analyzedAddressesDTO = transitAnalyzerController.analyze(client.getId(), address1.getId());
 
+
         //then
         // 1-2-5-4-5
-        org.assertj.core.api.Assertions
-                .assertThat(analyzedAddressesDTO.getAddresses().stream().map(AddressDTO::getHash).collect(Collectors.toList()))
-                .containsExactly(address1.getHash(), address2.getHash(), address5.getHash(), address4.getHash(), address5.getHash());
+        addressesContainExactly(analyzedAddressesDTO, address1, address2, address5, address4, address5);
     }
 
     @Test
@@ -122,9 +128,7 @@ void canFindLongestTravelFromMultipleClients() {
 
         //then
         // 1-2-3-4
-        org.assertj.core.api.Assertions
-                .assertThat(analyzedAddressesDTO.getAddresses().stream().map(AddressDTO::getHash).collect(Collectors.toList()))
-                .containsExactly(address1.getHash(), address2.getHash(), address3.getHash(), address4.getHash());
+        addressesContainExactly(analyzedAddressesDTO, address1, address2, address3, address4);
     }
 
     @Test
@@ -153,9 +157,7 @@ void canFindLongestTravelWithLongStops() {
 
         //then
         // 1-2-3-4
-        org.assertj.core.api.Assertions
-                .assertThat(analyzedAddressesDTO.getAddresses().stream().map(AddressDTO::getHash).collect(Collectors.toList()))
-                .containsExactly(address1.getHash(), address2.getHash(), address3.getHash(), address4.getHash());
+        addressesContainExactly(analyzedAddressesDTO, address1, address2, address3, address4);
     }
 
     @Test
@@ -193,15 +195,11 @@ void canFindLongestTravelWithLoops() {
 
         //then
         // 5-1-2-3
-        org.assertj.core.api.Assertions
-                .assertThat(analyzedAddressesDTO.getAddresses().stream().map(AddressDTO::getHash).collect(Collectors.toList()))
-                .containsExactly(address5.getHash(), address1.getHash(), address2.getHash(), address3.getHash());
+        addressesContainExactly(analyzedAddressesDTO, address5, address1, address2, address3);
     }
 
     @Test
-    // pytanie za 100 punktów, czy ten test będzie działał na grafie, bo tam jest warunek na ścieżkę o długości przynajmniej 1...
-    void canFindLongTravelBetweenOthers()
-    {
+    void canFindLongTravelBetweenOthers() {
         //given
         Client client = fixtures.aClient();
         //and
@@ -224,10 +222,22 @@ void canFindLongTravelBetweenOthers()
         AnalyzedAddressesDTO analyzedAddressesDTO = transitAnalyzerController.analyze(client.getId(), address1.getId());
 
         //then
-        //1-2
-        org.assertj.core.api.Assertions
-                .assertThat(analyzedAddressesDTO.getAddresses().stream().map(AddressDTO::getHash).collect(Collectors.toList()))
-                .containsExactly(address1.getHash(), address2.getHash(), address3.getHash());
+        //1-2-3
+        addressesContainExactly(analyzedAddressesDTO, address1, address2, address3);
+    }
+
+    void addressesContainExactly(AnalyzedAddressesDTO analyzedAddressesDTO, Address... expectedAddresses) {
+        List<Integer> expectedHashes = Stream.of(expectedAddresses)
+                .map(Address::getHash)
+                .collect(Collectors.toList());
+        await().ignoreExceptions().until(() -> {
+            assertThat(hashesOfAddresses(analyzedAddressesDTO)).containsExactlyElementsOf(expectedHashes);
+            return true;
+        });
+    }
+
+    List<Integer> hashesOfAddresses(AnalyzedAddressesDTO analyzedAddressesDTO) {
+        return analyzedAddressesDTO.getAddresses().stream().map(AddressDTO::getHash).collect(Collectors.toList());
     }
 
 }