Feature/amp 151 get subscriptiom

build.gradle

@@ -30,7 +30,7 @@ apply {
 }
 
 dependencies {
-  implementation(group: 'uk.gov.hmcts.cp', name: 'api-cp-crime-hearing-case-event-subscription', version: '0.1.0-724f10f')
+  implementation(group: 'uk.gov.hmcts.cp', name: 'api-cp-crime-hearing-case-event-subscription', version: '1.0.0')
 
   // This is proving to be a real puzzle. This is actually included in the api published pom
   // ( though with scope of "runtime" )

src/apiTest/java/uk/gov/hmcts/cp/http/ActuatorApiTest.java

@@ -1,7 +1,11 @@
 package uk.gov.hmcts.cp.http;
 
 import org.junit.jupiter.api.Test;
-import org.springframework.http.*;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.web.client.RestTemplate;
 
 import static org.assertj.core.api.Assertions.assertThat;

src/main/java/uk/gov/hmcts/cp/controllers/SubscriptionController.java

@@ -9,6 +9,8 @@
 import uk.gov.hmcts.cp.openapi.model.ClientSubscriptionRequest;
 import uk.gov.hmcts.cp.services.SubscriptionService;
 
+import java.util.UUID;
+
 @RestController
 @RequiredArgsConstructor
 @Slf4j
@@ -23,4 +25,12 @@ public ResponseEntity<ClientSubscription> createClientSubscription(final ClientS
         log.info("createClientSubscription created subscription:{}", response.getClientSubscriptionId());
         return ResponseEntity.ok(response);
     }
+
+    @Override
+    public ResponseEntity<ClientSubscription> getClientSubscription(final UUID clientSubscriptionId) {
+        log.info("getClientSubscription clientId:{}", "TODO");
+        final ClientSubscription response = subscriptionService.getSubscription(clientSubscriptionId);
+        log.info("createClientSubscription returning subscription:{}", response.getClientSubscriptionId());
+        return ResponseEntity.ok(response);
+    }
 }

src/main/java/uk/gov/hmcts/cp/entities/ClientSubscriptionEntity.java

@@ -1,8 +1,6 @@
 package uk.gov.hmcts.cp.entities;
 
 import jakarta.persistence.Entity;
-import jakarta.persistence.EnumType;
-import jakarta.persistence.Enumerated;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
@@ -11,9 +9,7 @@
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.CreationTimestamp;
-import org.hibernate.annotations.UpdateTimestamp;
-import uk.gov.hmcts.cp.model.EventType;
+import uk.gov.hmcts.cp.model.EntityEventType;
 
 import java.time.OffsetDateTime;
 import java.util.List;
@@ -32,10 +28,7 @@ public class ClientSubscriptionEntity {
     private UUID id;
 
     private String notificationEndpoint;
-    @Enumerated(EnumType.STRING)
-    private List<EventType> eventTypes;
-    @CreationTimestamp
+    private List<EntityEventType> eventTypes;
     private OffsetDateTime createdAt;
-    @UpdateTimestamp
     private OffsetDateTime updatedAt;
 }

src/main/java/uk/gov/hmcts/cp/mappers/SubscriptionMapper.java

@@ -2,21 +2,36 @@
 
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
+import org.mapstruct.Named;
 import org.mapstruct.ReportingPolicy;
 import uk.gov.hmcts.cp.entities.ClientSubscriptionEntity;
+import uk.gov.hmcts.cp.model.EntityEventType;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscription;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscriptionRequest;
+import uk.gov.hmcts.cp.openapi.model.EventType;
 import uk.gov.hmcts.cp.openapi.model.NotificationEndpoint;
 
 import java.net.URI;
+import java.util.List;
+
+import static java.util.stream.Collectors.toList;
 
 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
 public interface SubscriptionMapper {
 
+    @Mapping(source = "request.eventTypes", target = "eventTypes", qualifiedByName = "sortedEventTypes")
+    @Mapping(target = "createdAt", expression = "java(java.time.OffsetDateTime.now())")
+    @Mapping(target = "updatedAt", expression = "java(java.time.OffsetDateTime.now())")
     ClientSubscriptionEntity mapRequestToEntity(ClientSubscriptionRequest request);
 
     @Mapping(source = "id", target = "clientSubscriptionId")
-    ClientSubscription mapEntityToResponse(ClientSubscriptionEntity subscription);
+    ClientSubscription mapEntityToResponse(ClientSubscriptionEntity entity);
+
+    @Named("sortedEventTypes")
+    static List<EntityEventType> sortedEventTypes(final List<EventType> events) {
+        final List<String> sorted = events.stream().map(e -> e.name()).sorted().collect(toList());
+        return sorted.stream().map(e -> EntityEventType.valueOf(e)).toList();
+    }
 
     static String mapFromNotificationEndpoint(final NotificationEndpoint notificationEndpoint) {
         return notificationEndpoint.getWebhookUrl().toString();

src/main/java/uk/gov/hmcts/cp/model/EventType.java → src/main/java/uk/gov/hmcts/cp/model/EntityEventType.java

@@ -1,6 +1,6 @@
 package uk.gov.hmcts.cp.model;
 
-public enum EventType {
+public enum EntityEventType {
     PCR,
     CUSTODIAL_RESULT
 }

src/main/java/uk/gov/hmcts/cp/services/SubscriptionService.java

@@ -9,6 +9,8 @@
 import uk.gov.hmcts.cp.openapi.model.ClientSubscriptionRequest;
 import uk.gov.hmcts.cp.repositories.SubscriptionRepository;
 
+import java.util.UUID;
+
 @Service
 @RequiredArgsConstructor
 @Slf4j
@@ -21,4 +23,9 @@ public ClientSubscription saveSubscription(final ClientSubscriptionRequest reque
         final ClientSubscriptionEntity entity = mapper.mapRequestToEntity(request);
         return mapper.mapEntityToResponse(subscriptionRepository.save(entity));
     }
+
+    public ClientSubscription getSubscription(final UUID clientSubscriptionId) {
+        final ClientSubscriptionEntity entity = subscriptionRepository.getReferenceById(clientSubscriptionId);
+        return mapper.mapEntityToResponse(entity);
+    }
 }

src/main/resources/db/migration/V1.001__subscription_schema.sql

@@ -1,7 +1,7 @@
 create table client_subscription (
     id                      uuid primary key not null,
-    event_types              varchar(2048) not null,
-    notification_endpoint   text        not null,
+    event_types             varchar(128) not null,
+    notification_endpoint   varchar(2048) not null,
     created_at              timestamp not null,
-    updated_at              timestamp
+    updated_at              timestamp not null
 );

src/test/java/uk/gov/hmcts/cp/controllers/SubscriptionControllerTest.java

@@ -5,12 +5,14 @@
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.ResponseEntity;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscription;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscriptionRequest;
 import uk.gov.hmcts.cp.services.SubscriptionService;
 
 import java.util.UUID;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -28,10 +30,19 @@ class SubscriptionControllerTest {
 
     @Test
     void create_controller_should_call_service() {
-        UUID id = UUID.randomUUID();
-        ClientSubscription response = ClientSubscription.builder().clientSubscriptionId(id).build();
+        UUID subscriptionId = UUID.randomUUID();
+        ClientSubscription response = ClientSubscription.builder().clientSubscriptionId(subscriptionId).build();
         when(subscriptionService.saveSubscription(any())).thenReturn(response);
         subscriptionController.createClientSubscription(request);
         verify(subscriptionService).saveSubscription(request);
     }
+
+    @Test
+    void get_controller_should_call_service() {
+        UUID subscriptionId = UUID.randomUUID();
+        ClientSubscription response = ClientSubscription.builder().clientSubscriptionId(subscriptionId).build();
+        when(subscriptionService.getSubscription(subscriptionId)).thenReturn(response);
+        ResponseEntity<ClientSubscription> result = subscriptionController.getClientSubscription(subscriptionId);
+        assertThat(result.getBody()).isEqualTo(response);
+    }
 }

src/test/java/uk/gov/hmcts/cp/integration/IntegrationTestBase.java

@@ -2,11 +2,18 @@
 
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.web.servlet.MockMvc;
 import uk.gov.hmcts.cp.config.TestContainersInitialise;
+import uk.gov.hmcts.cp.entities.ClientSubscriptionEntity;
+import uk.gov.hmcts.cp.model.EntityEventType;
+import uk.gov.hmcts.cp.repositories.SubscriptionRepository;
+
+import java.time.OffsetDateTime;
+import java.util.List;
 
 @SpringBootTest
 @ContextConfiguration(initializers = TestContainersInitialise.class)
@@ -16,4 +23,18 @@ public abstract class IntegrationTestBase {
 
     @Resource
     protected MockMvc mockMvc;
+
+    @Autowired
+    SubscriptionRepository subscriptionRepository;
+
+    protected ClientSubscriptionEntity insertSubscription(String notificationUri, List<EntityEventType> entityEventTypes) {
+        ClientSubscriptionEntity subscription = ClientSubscriptionEntity.builder()
+                .eventTypes(entityEventTypes)
+                .notificationEndpoint(notificationUri)
+                .createdAt(OffsetDateTime.now())
+                .build();
+        ClientSubscriptionEntity saved = subscriptionRepository.save(subscription);
+        log.info("Inserted subscription:{}", saved.getId());
+        return saved;
+    }
 }

src/test/java/uk/gov/hmcts/cp/integration/SubscriptionControllerIntegrationTest.java

@@ -1,22 +1,33 @@
 package uk.gov.hmcts.cp.integration;
 
 import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
 import org.springframework.transaction.annotation.Transactional;
 import tools.jackson.databind.ObjectMapper;
+import uk.gov.hmcts.cp.entities.ClientSubscriptionEntity;
+import uk.gov.hmcts.cp.model.EntityEventType;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscriptionRequest;
 import uk.gov.hmcts.cp.openapi.model.NotificationEndpoint;
+import uk.gov.hmcts.cp.repositories.SubscriptionRepository;
 
 import java.net.URI;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 import static uk.gov.hmcts.cp.openapi.model.EventType.CUSTODIAL_RESULT;
 import static uk.gov.hmcts.cp.openapi.model.EventType.PCR;
 
 class SubscriptionControllerIntegrationTest extends IntegrationTestBase {
 
+    @Autowired
+    SubscriptionRepository subscriptionRepository;
+
     NotificationEndpoint notificationEndpoint = NotificationEndpoint.builder()
             .webhookUrl(URI.create("https://my-callback-url"))
             .build();
@@ -29,10 +40,36 @@ class SubscriptionControllerIntegrationTest extends IntegrationTestBase {
     @Transactional
     void save_client_subscription_should_save_subscription() throws Exception {
         String body = new ObjectMapper().writeValueAsString(request);
-        mockMvc.perform(post("/clientSubscriptions")
+        mockMvc.perform(post("/client-subscriptions")
                         .contentType(MediaType.APPLICATION_JSON)
                         .header("client-id-todo", "1234")
                         .content(body))
-                .andExpect(status().isOk());
+                .andDo(print())
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.clientSubscriptionId").exists())
+                .andExpect(jsonPath("$.eventTypes.[0]").value("CUSTODIAL_RESULT"))
+                .andExpect(jsonPath("$.eventTypes.[1]").value("PCR"))
+                .andExpect(jsonPath("$.createdAt").exists());
+        assertThatEventTypesAreSortedInDatabase();
+    }
+
+    @Test
+    @Transactional
+    void get_subscription_should_return_expected() throws Exception {
+        ClientSubscriptionEntity entity = insertSubscription("http://example.com/event", List.of(EntityEventType.PCR));
+        mockMvc.perform(get("/client-subscriptions/{id}", entity.getId())
+                        .header("client-id-todo", "1234"))
+                .andDo(print())
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.clientSubscriptionId").value(entity.getId().toString()))
+                .andExpect(jsonPath("$.eventTypes.[0]").value("PCR"))
+                .andExpect(jsonPath("$.createdAt").exists());
+    }
+
+    private void assertThatEventTypesAreSortedInDatabase() {
+        List<ClientSubscriptionEntity> entities = subscriptionRepository.findAll();
+        assertThat(entities).hasSize(1);
+        assertThat(entities.get(0).getEventTypes().get(0)).isEqualTo(EntityEventType.CUSTODIAL_RESULT);
+        assertThat(entities.get(0).getEventTypes().get(1)).isEqualTo(EntityEventType.PCR);
     }
 }

src/test/java/uk/gov/hmcts/cp/mappers/SubscriptionMapperTest.java

@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.Test;
 import uk.gov.hmcts.cp.entities.ClientSubscriptionEntity;
+import uk.gov.hmcts.cp.model.EntityEventType;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscription;
 import uk.gov.hmcts.cp.openapi.model.ClientSubscriptionRequest;
 import uk.gov.hmcts.cp.openapi.model.NotificationEndpoint;
@@ -12,7 +13,7 @@
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static uk.gov.hmcts.cp.model.EventType.CUSTODIAL_RESULT;
+import static uk.gov.hmcts.cp.openapi.model.EventType.CUSTODIAL_RESULT;
 import static uk.gov.hmcts.cp.openapi.model.EventType.PCR;
 
 class SubscriptionMapperTest {
@@ -27,27 +28,27 @@ class SubscriptionMapperTest {
     OffsetDateTime updatedAt = OffsetDateTime.now().minusHours(2);
 
     @Test
-    void request_should_map_to_entity() {
+    void request_should_map_to_entity_with_sorted_types() {
         ClientSubscriptionRequest request = ClientSubscriptionRequest.builder()
                 .notificationEndpoint(notificationEndpoint)
-                .eventTypes(List.of(PCR))
+                .eventTypes(List.of(PCR, CUSTODIAL_RESULT))
                 .build();
 
         ClientSubscriptionEntity entity = mapper.mapRequestToEntity(request);
 
         assertThat(entity.getId()).isNull();
         assertThat(entity.getNotificationEndpoint()).isEqualTo("https://example.com");
-        assertThat(entity.getEventTypes().toString()).isEqualTo("[PCR]");
-        assertThat(entity.getCreatedAt()).isNull();
-        assertThat(entity.getUpdatedAt()).isNull();
+        assertThat(entity.getEventTypes().toString()).isEqualTo("[CUSTODIAL_RESULT, PCR]");
+        assertThat(entity.getCreatedAt()).isNotNull();
+        assertThat(entity.getUpdatedAt()).isNotNull();
     }
 
     @Test
     void entity_should_map_to_response() {
         ClientSubscriptionEntity clientSubscriptionEntity = ClientSubscriptionEntity.builder()
                 .id(clientNotificationId)
                 .notificationEndpoint(notificationEndpoint.getWebhookUrl().toString())
-                .eventTypes(List.of(CUSTODIAL_RESULT))
+                .eventTypes(List.of(EntityEventType.CUSTODIAL_RESULT, EntityEventType.PCR))
                 .createdAt(createdAt)
                 .updatedAt(updatedAt)
                 .build();
@@ -56,7 +57,7 @@ void entity_should_map_to_response() {
 
         assertThat(subscription.getClientSubscriptionId()).isEqualTo(clientNotificationId);
         assertThat(subscription.getNotificationEndpoint()).isEqualTo(notificationEndpoint);
-        assertThat(subscription.getEventTypes().toString()).isEqualTo("[CUSTODIAL_RESULT]");
+        assertThat(subscription.getEventTypes().toString()).isEqualTo("[CUSTODIAL_RESULT, PCR]");
         assertThat(subscription.getCreatedAt()).isEqualTo(createdAt);
         assertThat(subscription.getUpdatedAt()).isEqualTo(updatedAt);
     }

src/test/java/uk/gov/hmcts/cp/repositories/RepositoryTestBase.java

@@ -7,8 +7,9 @@
 import org.springframework.test.context.ContextConfiguration;
 import uk.gov.hmcts.cp.config.TestContainersInitialise;
 import uk.gov.hmcts.cp.entities.ClientSubscriptionEntity;
-import uk.gov.hmcts.cp.model.EventType;
+import uk.gov.hmcts.cp.model.EntityEventType;
 
+import java.time.OffsetDateTime;
 import java.util.List;
 
 @SpringBootTest
@@ -25,10 +26,11 @@ protected void clearAllTables() {
         subscriptionRepository.deleteAll();
     }
 
-    protected ClientSubscriptionEntity insertSubscription(String notificationUri, List<EventType> eventTypes) {
+    protected ClientSubscriptionEntity insertSubscription(String notificationUri, List<EntityEventType> entityEventTypes) {
         ClientSubscriptionEntity subscription = ClientSubscriptionEntity.builder()
-                .eventTypes(eventTypes)
+                .eventTypes(entityEventTypes)
                 .notificationEndpoint(notificationUri)
+                .createdAt(OffsetDateTime.now())
                 .build();
         ClientSubscriptionEntity saved = subscriptionRepository.save(subscription);
         log.info("Inserted subscription:{}", saved.getId());