HDPI-5180: Persist basic citizen General Application

src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/PCSCase.java

@@ -18,6 +18,7 @@
 import uk.gov.hmcts.reform.pcs.ccd.accesscontrol.ClaimantAccess;
 import uk.gov.hmcts.reform.pcs.ccd.accesscontrol.DefendantAccess;
 import uk.gov.hmcts.reform.pcs.ccd.accesscontrol.GlobalSearchAccess;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.CitizenGenAppRequest;
 import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder;
 import uk.gov.hmcts.reform.pcs.ccd.domain.grounds.AssuredNoArrearsPossessionGrounds;
 import uk.gov.hmcts.reform.pcs.ccd.domain.grounds.AssuredRentArrearsPossessionGrounds;
@@ -500,6 +501,9 @@ public class PCSCase {
     @CCD(access = {ClaimantAccess.class, DefendantAccess.class})
     private List<ListValue<ClaimGroundSummary>> claimGroundSummaries;
 
+    @CCD(access = DefendantAccess.class)
+    private CitizenGenAppRequest citizenGenAppRequest;
+
     @CCD(
         label = "Search Criteria",
         access = {GlobalSearchAccess.class}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/genapp/CitizenGenAppRequest.java

@@ -0,0 +1,16 @@
+package uk.gov.hmcts.reform.pcs.ccd.domain.genapp;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Builder
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class CitizenGenAppRequest {
+
+    private GenAppType applicationType;
+
+}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/genapp/GenAppState.java

@@ -0,0 +1,8 @@
+package uk.gov.hmcts.reform.pcs.ccd.domain.genapp;
+
+public enum GenAppState {
+
+    PENDING_SUBMISSION,
+    SUBMITTED
+
+}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/genapp/GenAppType.java

@@ -0,0 +1,10 @@
+package uk.gov.hmcts.reform.pcs.ccd.domain.genapp;
+
+public enum GenAppType {
+
+    SUSPEND,
+    ADJOURN,
+    SET_ASIDE,
+    SOMETHING_ELSE
+
+}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/GenAppEntity.java

@@ -0,0 +1,56 @@
+package uk.gov.hmcts.reform.pcs.ccd.entity;
+
+import com.fasterxml.jackson.annotation.JsonBackReference;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.GenAppType;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.GenAppState;
+import uk.gov.hmcts.reform.pcs.ccd.entity.party.PartyEntity;
+
+import java.util.UUID;
+
+import static jakarta.persistence.FetchType.EAGER;
+import static jakarta.persistence.FetchType.LAZY;
+
+@Entity
+@Builder
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "general_application")
+public class GenAppEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+
+    @ManyToOne(fetch = LAZY)
+    @JoinColumn(name = "case_id")
+    @JsonBackReference
+    private PcsCaseEntity pcsCase;
+
+    @Enumerated(EnumType.STRING)
+    private GenAppType type;
+
+    @Enumerated(EnumType.STRING)
+    private GenAppState state;
+
+    @ManyToOne(fetch = EAGER)
+    @JoinColumn(name = "party_id")
+    @JsonBackReference
+    private PartyEntity party;
+
+}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/PcsCaseEntity.java

@@ -73,6 +73,11 @@ public class PcsCaseEntity {
     @JsonManagedReference
     private List<ClaimEntity> claims = new ArrayList<>();
 
+    @OneToMany(mappedBy = "pcsCase", fetch = LAZY, cascade = ALL)
+    @Builder.Default
+    @JsonManagedReference
+    private Set<GenAppEntity> genApps = new HashSet<>();
+
     @OneToMany(mappedBy = "pcsCase", fetch = LAZY, cascade = ALL)
     @Builder.Default
     @JsonManagedReference
@@ -100,6 +105,11 @@ public void addClaim(ClaimEntity claim) {
         claim.setPcsCase(this);
     }
 
+    public void addGenApp(GenAppEntity genApp) {
+        genApps.add(genApp);
+        genApp.setPcsCase(this);
+    }
+
     public void addParty(PartyEntity party) {
         parties.add(party);
         party.setPcsCase(this);

src/main/java/uk/gov/hmcts/reform/pcs/ccd/event/EventId.java

@@ -7,5 +7,6 @@ public enum EventId {
     enforceTheOrder,
     respondPossessionClaim,
     submitDefendantResponse,
+    citizenCreateGenApp,
     createTestCase
 }

src/main/java/uk/gov/hmcts/reform/pcs/ccd/event/citizen/CitizenCreateGenApp.java

@@ -0,0 +1,75 @@
+package uk.gov.hmcts.reform.pcs.ccd.event.citizen;
+
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import uk.gov.hmcts.ccd.sdk.api.CCDConfig;
+import uk.gov.hmcts.ccd.sdk.api.DecentralisedConfigBuilder;
+import uk.gov.hmcts.ccd.sdk.api.EventPayload;
+import uk.gov.hmcts.ccd.sdk.api.Permission;
+import uk.gov.hmcts.ccd.sdk.api.callback.SubmitResponse;
+import uk.gov.hmcts.reform.pcs.ccd.ShowConditions;
+import uk.gov.hmcts.reform.pcs.ccd.accesscontrol.UserRole;
+import uk.gov.hmcts.reform.pcs.ccd.domain.PCSCase;
+import uk.gov.hmcts.reform.pcs.ccd.domain.State;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.CitizenGenAppRequest;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.GenAppState;
+import uk.gov.hmcts.reform.pcs.ccd.entity.GenAppEntity;
+import uk.gov.hmcts.reform.pcs.ccd.entity.PcsCaseEntity;
+import uk.gov.hmcts.reform.pcs.ccd.entity.party.PartyEntity;
+import uk.gov.hmcts.reform.pcs.ccd.repository.GenAppRepository;
+import uk.gov.hmcts.reform.pcs.ccd.service.PcsCaseService;
+import uk.gov.hmcts.reform.pcs.ccd.service.party.PartyService;
+import uk.gov.hmcts.reform.pcs.security.SecurityContextService;
+
+import java.util.UUID;
+
+import static uk.gov.hmcts.reform.pcs.ccd.event.EventId.citizenCreateGenApp;
+
+@Slf4j
+@Component
+@AllArgsConstructor
+public class CitizenCreateGenApp implements CCDConfig<PCSCase, State, UserRole> {
+
+    private final PcsCaseService pcsCaseService;
+    private final PartyService partyService;
+    private final SecurityContextService securityContextService;
+    private final GenAppRepository genAppRepository;
+
+    @Override
+    public void configureDecentralised(DecentralisedConfigBuilder<PCSCase, State, UserRole> configBuilder) {
+        configBuilder
+            .decentralisedEvent(citizenCreateGenApp.name(), this::submit)
+            .forAllStates() // TODO: Adjust once target states are known and available
+            .name("Create a General Application")
+            .showCondition(ShowConditions.NEVER_SHOW)
+            .grant(Permission.CRUD, UserRole.DEFENDANT)
+            .showSummary();
+    }
+
+    private SubmitResponse<State> submit(EventPayload<PCSCase, State> eventPayload) {
+        long caseReference = eventPayload.caseReference();
+        PCSCase caseData = eventPayload.caseData();
+
+        PcsCaseEntity pcsCaseEntity = pcsCaseService.loadCase(caseReference);
+
+        UUID currentUserId = securityContextService.getCurrentUserId();
+        PartyEntity applicantParty = partyService.getPartyEntityByIdamId(currentUserId, caseReference);
+
+        CitizenGenAppRequest citizenCreateGenApp = caseData.getCitizenGenAppRequest();
+
+        GenAppEntity genAppEntity = GenAppEntity.builder()
+            .type(citizenCreateGenApp.getApplicationType())
+            .party(applicantParty)
+            .state(GenAppState.SUBMITTED)
+            .build();
+
+        genAppRepository.save(genAppEntity);
+
+        pcsCaseEntity.addGenApp(genAppEntity);
+
+        return SubmitResponse.<State>builder()
+            .build();
+    }
+
+}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/repository/GenAppRepository.java

@@ -0,0 +1,12 @@
+package uk.gov.hmcts.reform.pcs.ccd.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import uk.gov.hmcts.reform.pcs.ccd.entity.GenAppEntity;
+
+import java.util.UUID;
+
+@Repository
+public interface GenAppRepository extends JpaRepository<GenAppEntity, UUID> {
+
+}

src/main/resources/db/migration/V075__general_application.sql

@@ -0,0 +1,7 @@
+CREATE TABLE general_application (
+  id       UUID PRIMARY KEY,
+  case_id  UUID REFERENCES public.pcs_case (id),
+  type     VARCHAR(50),
+  state    VARCHAR(30),
+  party_id UUID REFERENCES public.party (id)
+)

src/test/java/uk/gov/hmcts/reform/pcs/ccd/event/citizen/CitizenCreateGenAppTest.java

@@ -0,0 +1,153 @@
+package uk.gov.hmcts.reform.pcs.ccd.event.citizen;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.GenAppType;
+import uk.gov.hmcts.reform.pcs.ccd.domain.PCSCase;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.CitizenGenAppRequest;
+import uk.gov.hmcts.reform.pcs.ccd.domain.genapp.GenAppState;
+import uk.gov.hmcts.reform.pcs.ccd.entity.GenAppEntity;
+import uk.gov.hmcts.reform.pcs.ccd.entity.PcsCaseEntity;
+import uk.gov.hmcts.reform.pcs.ccd.entity.party.PartyEntity;
+import uk.gov.hmcts.reform.pcs.ccd.event.BaseEventTest;
+import uk.gov.hmcts.reform.pcs.ccd.repository.GenAppRepository;
+import uk.gov.hmcts.reform.pcs.ccd.service.PcsCaseService;
+import uk.gov.hmcts.reform.pcs.ccd.service.party.PartyService;
+import uk.gov.hmcts.reform.pcs.security.SecurityContextService;
+
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class CitizenCreateGenAppTest extends BaseEventTest {
+
+    @Mock
+    private PcsCaseService pcsCaseService;
+    @Mock
+    private PartyService partyService;
+    @Mock
+    private SecurityContextService securityContextService;
+    @Mock
+    private GenAppRepository genAppRepository;
+
+    @BeforeEach
+    void setUp() {
+        CitizenCreateGenApp underTest = new CitizenCreateGenApp(pcsCaseService, partyService,
+                                                                securityContextService, genAppRepository);
+
+        setEventUnderTest(underTest);
+    }
+
+    @Nested
+    @DisplayName("Submit event tests")
+    class SubmitTests {
+
+        @Mock
+        private PcsCaseEntity pcsCaseEntity;
+
+        @BeforeEach
+        void setUp() {
+            given(pcsCaseService.loadCase(TEST_CASE_REFERENCE)).willReturn(pcsCaseEntity);
+        }
+
+        @ParameterizedTest
+        @EnumSource(value = GenAppType.class)
+        void shouldSetGeneralApplicationType(GenAppType genAppType) {
+            // Given
+            CitizenGenAppRequest genAppRequest = CitizenGenAppRequest.builder()
+                .applicationType(genAppType)
+                .build();
+
+            PCSCase caseData = PCSCase.builder()
+                .citizenGenAppRequest(genAppRequest)
+                .build();
+
+            // When
+            callSubmitHandler(caseData);
+
+            // Then
+            ArgumentCaptor<GenAppEntity> genAppEntityCaptor = ArgumentCaptor.forClass(GenAppEntity.class);
+            verify(genAppRepository).save(genAppEntityCaptor.capture());
+
+            assertThat(genAppEntityCaptor.getValue().getType()).isEqualTo(genAppType);
+        }
+
+        @Test
+        void shouldSetInitialState() {
+            // Given
+            CitizenGenAppRequest genAppRequest = CitizenGenAppRequest.builder()
+                .build();
+
+            PCSCase caseData = PCSCase.builder()
+                .citizenGenAppRequest(genAppRequest)
+                .build();
+
+            // When
+            callSubmitHandler(caseData);
+
+            // Then
+            ArgumentCaptor<GenAppEntity> genAppEntityCaptor = ArgumentCaptor.forClass(GenAppEntity.class);
+            verify(genAppRepository).save(genAppEntityCaptor.capture());
+
+            assertThat(genAppEntityCaptor.getValue().getState()).isEqualTo(GenAppState.SUBMITTED);
+        }
+
+        @Test
+        void shouldSetApplicantParty() {
+            // Given
+            final PartyEntity applicantParty = mock(PartyEntity.class);
+
+            CitizenGenAppRequest genAppRequest = CitizenGenAppRequest.builder()
+                .applicationType(GenAppType.SUSPEND)
+                .build();
+
+            PCSCase caseData = PCSCase.builder()
+                .citizenGenAppRequest(genAppRequest)
+                .build();
+
+            UUID currentUserId = UUID.randomUUID();
+            given(securityContextService.getCurrentUserId()).willReturn(currentUserId);
+            given(partyService.getPartyEntityByIdamId(currentUserId, TEST_CASE_REFERENCE)).willReturn(applicantParty);
+
+            // When
+            callSubmitHandler(caseData);
+
+            // Then
+            ArgumentCaptor<GenAppEntity> genAppEntityCaptor = ArgumentCaptor.forClass(GenAppEntity.class);
+            verify(genAppRepository).save(genAppEntityCaptor.capture());
+
+            assertThat(genAppEntityCaptor.getValue().getParty()).isEqualTo(applicantParty);
+        }
+
+        @Test
+        void shouldCreateGenAppAndAddToCaseEntity() {
+            // Given
+            PCSCase caseData = PCSCase.builder()
+                .citizenGenAppRequest(CitizenGenAppRequest.builder().build())
+                .build();
+
+            // When
+            callSubmitHandler(caseData);
+
+            // Then
+            ArgumentCaptor<GenAppEntity> genAppEntityCaptor = ArgumentCaptor.forClass(GenAppEntity.class);
+            verify(genAppRepository).save(genAppEntityCaptor.capture());
+
+            verify(pcsCaseEntity).addGenApp(same(genAppEntityCaptor.getValue()));
+        }
+
+    }
+}