Prevent going to completed tasks after signing

cypress/e2e/donor/dashboard.cy.js

@@ -68,15 +68,15 @@ describe('Dashboard', () => {
         });
     });
 
-    context('with submitted LPA', () => {
+    context('with signed LPA having pending task', () => {
         it('shows the correct options', () => {
             Cypress.on('uncaught:exception', () => {
                 // TODO: remove this if this test works without, it is a problem
                 // in the moj-frontend package
                 return false
             })
 
-            cy.visit('/fixtures?redirect=&progress=signTheLpa');
+            cy.visit('/fixtures?redirect=&progress=signTheLpa&idStatus=donor:insufficient-evidence');
 
             cy.get('button').should('not.contain', 'Continue');
 
@@ -91,6 +91,25 @@ describe('Dashboard', () => {
             cy.contains('a', 'Check LPA progress').click();
 
             cy.url().should('contain', '/progress');
+            cy.contains('a', 'Go to task list');
+        });
+    });
+
+    context('with submitted LPA', () => {
+        it('shows the correct options', () => {
+            cy.visit('/fixtures?redirect=&progress=signTheLpa');
+
+            cy.get('button').should('not.contain', 'Continue');
+
+            cy.contains('Property and affairs');
+            cy.contains('Sam Smith');
+            cy.contains('strong', 'In progress');
+            cy.contains('a', 'View LPA');
+            cy.contains('a', 'Revoke LPA');
+            cy.contains('a', 'Check LPA progress').click();
+
+            cy.url().should('contain', '/progress');
+            cy.contains('a', 'Go to task list').should('not.exist');
         });
     });
 

cypress/e2e/donor/people-to-notify.cy.js

@@ -137,14 +137,6 @@ describe('People to notify', () => {
         cy.url().should('contain', '/do-you-want-to-notify-people');
     });
 
-    it('hides action links when LPA has been signed', () => {
-        cy.visit('/fixtures?redirect=/choose-people-to-notify-summary&progress=signTheLpa');
-
-        cy.checkA11yApp();
-
-        cy.contains('Jordan Jefferson').parent().contains('a', 'Change').should('not.exist');
-    });
-
     it('limits people to notify to 5', () => {
         cy.visit('/fixtures?redirect=/choose-people-to-notify-summary&progress=peopleToNotifyAboutYourLpa&peopleToNotify=max');
 

internal/dashboard/dashboarddata/results.go

@@ -3,6 +3,7 @@ package dashboarddata
 import (
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/attorney/attorneydata"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/certificateprovider/certificateproviderdata"
+	"github.com/ministryofjustice/opg-modernising-lpa/internal/donor/donordata"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/lpastore/lpadata"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/voucher/voucherdata"
 )
@@ -16,6 +17,7 @@ type Results struct {
 
 type Actor struct {
 	Lpa                 *lpadata.Lpa
+	Donor               *donordata.Provided
 	CertificateProvider *certificateproviderdata.Provided
 	Attorney            *attorneydata.Provided
 	Voucher             *voucherdata.Provided

internal/dashboard/store.go

@@ -155,14 +155,15 @@ func (s *Store) GetAll(ctx context.Context) (results dashboarddata.Results, err
 		return results, err
 	}
 
+	donorMap := map[string]dashboarddata.Actor{}
 	certificateProviderMap := map[string]dashboarddata.Actor{}
 	attorneyMap := map[string]dashboarddata.Actor{}
 	voucherMap := map[string]dashboarddata.Actor{}
 
 	for _, lpa := range resolvedLpas {
 		switch keyMap[lpa.LpaID] {
 		case actor.TypeDonor:
-			results.Donor = append(results.Donor, dashboarddata.Actor{Lpa: lpa})
+			donorMap[lpa.LpaID] = dashboarddata.Actor{Lpa: lpa}
 		case actor.TypeAttorney:
 			attorneyMap[lpa.LpaID] = dashboarddata.Actor{Lpa: lpa}
 		case actor.TypeCertificateProvider:
@@ -179,6 +180,20 @@ func (s *Store) GetAll(ctx context.Context) (results dashboarddata.Results, err
 		}
 
 		switch ks.SK.(type) {
+		case dynamo.DonorKeyType:
+			donorProvidedDetails := &donordata.Provided{}
+			if err := attributevalue.UnmarshalMap(item, donorProvidedDetails); err != nil {
+				return results, err
+			}
+
+			lpaID := donorProvidedDetails.LpaID
+
+			if entry, ok := donorMap[lpaID]; ok {
+				entry.Donor = donorProvidedDetails
+				donorMap[lpaID] = entry
+				continue
+			}
+
 		case dynamo.AttorneyKeyType:
 			attorneyProvidedDetails := &attorneydata.Provided{}
 			if err := attributevalue.UnmarshalMap(item, attorneyProvidedDetails); err != nil {
@@ -235,12 +250,18 @@ func (s *Store) GetAll(ctx context.Context) (results dashboarddata.Results, err
 		}
 	}
 
+	results.Donor = mapValues(donorMap)
 	results.CertificateProvider = mapValues(certificateProviderMap)
 	results.Attorney = mapValues(attorneyMap)
 	results.Voucher = mapValues(voucherMap)
 
 	byUpdatedAt := func(a, b dashboarddata.Actor) int {
-		return b.Lpa.UpdatedAt.Compare(a.Lpa.UpdatedAt)
+		cmp := b.Lpa.UpdatedAt.Compare(a.Lpa.UpdatedAt)
+		if cmp != 0 {
+			return cmp
+		}
+
+		return strings.Compare(b.Lpa.LpaUID, a.Lpa.LpaUID)
 	}
 
 	slices.SortFunc(results.Donor, byUpdatedAt)

internal/dashboard/store_test.go

@@ -45,41 +45,41 @@ func TestDashboardStoreGetAll(t *testing.T) {
 	sessionID := "an-id"
 	aTime := time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC)
 
-	lpa0 := &lpadata.Lpa{LpaID: "0", LpaUID: "M", UpdatedAt: aTime}
+	lpa0 := &lpadata.Lpa{LpaID: "0", LpaUID: "M-0", UpdatedAt: aTime}
 	lpa0Donor := &donordata.Provided{
 		PK:        dynamo.LpaKey("0"),
 		SK:        dynamo.LpaOwnerKey(dynamo.DonorKey(sessionID)),
 		LpaID:     "0",
-		LpaUID:    "M",
+		LpaUID:    "M-0",
 		UpdatedAt: aTime,
 	}
-	lpa123 := &lpadata.Lpa{LpaID: "123", LpaUID: "M", UpdatedAt: aTime}
+	lpa123 := &lpadata.Lpa{LpaID: "123", LpaUID: "M-123", UpdatedAt: aTime}
 	lpa123Donor := &donordata.Provided{
 		PK:        dynamo.LpaKey("123"),
 		SK:        dynamo.LpaOwnerKey(dynamo.DonorKey(sessionID)),
 		LpaID:     "123",
-		LpaUID:    "M",
+		LpaUID:    "M-123",
 		UpdatedAt: aTime,
 	}
-	lpa456 := &lpadata.Lpa{LpaID: "456", LpaUID: "M"}
+	lpa456 := &lpadata.Lpa{LpaID: "456", LpaUID: "M-456"}
 	lpa456Donor := &donordata.Provided{
 		PK:     dynamo.LpaKey("456"),
 		SK:     dynamo.LpaOwnerKey(dynamo.DonorKey("another-id")),
 		LpaID:  "456",
-		LpaUID: "M",
+		LpaUID: "M-456",
 	}
 	lpa456CertificateProvider := &certificateproviderdata.Provided{
 		PK:    dynamo.LpaKey("456"),
 		SK:    dynamo.CertificateProviderKey(sessionID),
 		LpaID: "456",
 		Tasks: certificateproviderdata.Tasks{ConfirmYourDetails: task.StateCompleted},
 	}
-	lpa789 := &lpadata.Lpa{LpaID: "789", LpaUID: "M"}
+	lpa789 := &lpadata.Lpa{LpaID: "789", LpaUID: "M-789"}
 	lpa789Donor := &donordata.Provided{
 		PK:     dynamo.LpaKey("789"),
 		SK:     dynamo.LpaOwnerKey(dynamo.DonorKey("different-id")),
 		LpaID:  "789",
-		LpaUID: "M",
+		LpaUID: "M-789",
 	}
 	lpa789Attorney := &attorneydata.Provided{
 		PK:    dynamo.LpaKey("789"),
@@ -93,12 +93,12 @@ func TestDashboardStoreGetAll(t *testing.T) {
 		LpaID:     "999",
 		UpdatedAt: aTime,
 	}
-	lpaCertified := &lpadata.Lpa{LpaID: "signed-by-cp", LpaUID: "M"}
+	lpaCertified := &lpadata.Lpa{LpaID: "signed-by-cp", LpaUID: "M-signed-by-cp"}
 	lpaCertifiedDonor := &donordata.Provided{
 		PK:     dynamo.LpaKey("signed-by-cp"),
 		SK:     dynamo.LpaOwnerKey(dynamo.DonorKey("another-id")),
 		LpaID:  "signed-by-cp",
-		LpaUID: "M",
+		LpaUID: "M-signed-by-cp",
 	}
 	lpaCertifiedCertificateProvider := &certificateproviderdata.Provided{
 		PK:       dynamo.LpaKey("signed-by-cp"),
@@ -230,7 +230,7 @@ func TestDashboardStoreGetAll(t *testing.T) {
 			assert.Nil(t, err)
 
 			assert.Equal(t, dashboarddata.Results{
-				Donor:               []dashboarddata.Actor{{Lpa: lpa123}, {Lpa: lpa0}, {Lpa: lpaReferenced}},
+				Donor:               []dashboarddata.Actor{{Lpa: lpa123, Donor: lpa123Donor}, {Lpa: lpa0, Donor: lpa0Donor}, {Lpa: lpaReferenced}},
 				CertificateProvider: []dashboarddata.Actor{{Lpa: lpa456, CertificateProvider: lpa456CertificateProvider}},
 				Attorney:            []dashboarddata.Actor{{Lpa: lpa789, Attorney: lpa789Attorney}},
 				Voucher:             []dashboarddata.Actor{{Lpa: lpaVouched, Voucher: lpaVouchedVoucher}},

internal/donor/donordata/provided.go

@@ -196,6 +196,23 @@ type Provided struct {
 	HasSentApplicationUpdatedEvent bool `hash:"-" checkhash:"-"`
 }
 
+func (p *Provided) CompletedAllTasks() bool {
+	return p.Tasks.YourDetails.IsCompleted() &&
+		p.Tasks.ChooseAttorneys.IsCompleted() &&
+		p.Tasks.ChooseReplacementAttorneys.IsCompleted() &&
+		(p.Type.IsPropertyAndAffairs() && p.Tasks.WhenCanTheLpaBeUsed.IsCompleted() ||
+			p.Type.IsPersonalWelfare() && p.Tasks.LifeSustainingTreatment.IsCompleted()) &&
+		p.Tasks.Restrictions.IsCompleted() &&
+		p.Tasks.CertificateProvider.IsCompleted() &&
+		p.Tasks.PeopleToNotify.IsCompleted() &&
+		p.Tasks.AddCorrespondent.IsCompleted() &&
+		(p.Donor.CanSign.IsYes() || p.Tasks.ChooseYourSignatory.IsCompleted()) &&
+		p.Tasks.CheckYourLpa.IsCompleted() &&
+		p.Tasks.PayForLpa.IsCompleted() &&
+		p.Tasks.ConfirmYourIdentity.IsCompleted() &&
+		p.Tasks.SignTheLpa.IsCompleted()
+}
+
 // CanChange returns true if the donor can make changes to their LPA.
 func (p *Provided) CanChange() bool {
 	return p.SignedAt.IsZero()

internal/donor/donordata/provided_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/actor"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/actor/actoruid"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/date"
+	"github.com/ministryofjustice/opg-modernising-lpa/internal/form"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/identity"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/lpastore/lpadata"
 	"github.com/ministryofjustice/opg-modernising-lpa/internal/pay"
@@ -25,6 +26,145 @@ var address = place.Address{
 	Postcode:   "e",
 }
 
+func TestProvidedCompletedAllTasks(t *testing.T) {
+	testcases := map[string]struct {
+		provided *Provided
+		expected bool
+	}{
+		"none": {
+			provided: &Provided{},
+		},
+		"missing property and affairs": {
+			provided: &Provided{
+				Type:  lpadata.LpaTypePropertyAndAffairs,
+				Donor: Donor{CanSign: form.Yes},
+				Tasks: Tasks{
+					YourDetails:                task.StateCompleted,
+					ChooseAttorneys:            task.StateCompleted,
+					ChooseReplacementAttorneys: task.StateCompleted,
+					Restrictions:               task.StateCompleted,
+					CertificateProvider:        task.StateCompleted,
+					PeopleToNotify:             task.StateCompleted,
+					AddCorrespondent:           task.StateCompleted,
+					CheckYourLpa:               task.StateCompleted,
+					PayForLpa:                  task.PaymentStateCompleted,
+					ConfirmYourIdentity:        task.IdentityStateCompleted,
+					SignTheLpa:                 task.StateCompleted,
+				},
+			},
+		},
+		"all property and affairs": {
+			provided: &Provided{
+				Type:  lpadata.LpaTypePropertyAndAffairs,
+				Donor: Donor{CanSign: form.Yes},
+				Tasks: Tasks{
+					YourDetails:                task.StateCompleted,
+					ChooseAttorneys:            task.StateCompleted,
+					ChooseReplacementAttorneys: task.StateCompleted,
+					WhenCanTheLpaBeUsed:        task.StateCompleted,
+					Restrictions:               task.StateCompleted,
+					CertificateProvider:        task.StateCompleted,
+					PeopleToNotify:             task.StateCompleted,
+					AddCorrespondent:           task.StateCompleted,
+					CheckYourLpa:               task.StateCompleted,
+					PayForLpa:                  task.PaymentStateCompleted,
+					ConfirmYourIdentity:        task.IdentityStateCompleted,
+					SignTheLpa:                 task.StateCompleted,
+				},
+			},
+			expected: true,
+		},
+		"missing personal welfare": {
+			provided: &Provided{
+				Type:  lpadata.LpaTypePersonalWelfare,
+				Donor: Donor{CanSign: form.Yes},
+				Tasks: Tasks{
+					YourDetails:                task.StateCompleted,
+					ChooseAttorneys:            task.StateCompleted,
+					ChooseReplacementAttorneys: task.StateCompleted,
+					Restrictions:               task.StateCompleted,
+					CertificateProvider:        task.StateCompleted,
+					PeopleToNotify:             task.StateCompleted,
+					AddCorrespondent:           task.StateCompleted,
+					CheckYourLpa:               task.StateCompleted,
+					PayForLpa:                  task.PaymentStateCompleted,
+					ConfirmYourIdentity:        task.IdentityStateCompleted,
+					SignTheLpa:                 task.StateCompleted,
+				},
+			},
+		},
+		"all personal welfare": {
+			provided: &Provided{
+				Type:  lpadata.LpaTypePersonalWelfare,
+				Donor: Donor{CanSign: form.Yes},
+				Tasks: Tasks{
+					YourDetails:                task.StateCompleted,
+					ChooseAttorneys:            task.StateCompleted,
+					ChooseReplacementAttorneys: task.StateCompleted,
+					LifeSustainingTreatment:    task.StateCompleted,
+					Restrictions:               task.StateCompleted,
+					CertificateProvider:        task.StateCompleted,
+					PeopleToNotify:             task.StateCompleted,
+					AddCorrespondent:           task.StateCompleted,
+					CheckYourLpa:               task.StateCompleted,
+					PayForLpa:                  task.PaymentStateCompleted,
+					ConfirmYourIdentity:        task.IdentityStateCompleted,
+					SignTheLpa:                 task.StateCompleted,
+				},
+			},
+			expected: true,
+		},
+		"missing cannot sign": {
+			provided: &Provided{
+				Type:  lpadata.LpaTypePersonalWelfare,
+				Donor: Donor{CanSign: form.No},
+				Tasks: Tasks{
+					YourDetails:                task.StateCompleted,
+					ChooseAttorneys:            task.StateCompleted,
+					ChooseReplacementAttorneys: task.StateCompleted,
+					LifeSustainingTreatment:    task.StateCompleted,
+					Restrictions:               task.StateCompleted,
+					CertificateProvider:        task.StateCompleted,
+					PeopleToNotify:             task.StateCompleted,
+					AddCorrespondent:           task.StateCompleted,
+					CheckYourLpa:               task.StateCompleted,
+					PayForLpa:                  task.PaymentStateCompleted,
+					ConfirmYourIdentity:        task.IdentityStateCompleted,
+					SignTheLpa:                 task.StateCompleted,
+				},
+			},
+		},
+		"all cannot sign": {
+			provided: &Provided{
+				Type:  lpadata.LpaTypePersonalWelfare,
+				Donor: Donor{CanSign: form.No},
+				Tasks: Tasks{
+					YourDetails:                task.StateCompleted,
+					ChooseAttorneys:            task.StateCompleted,
+					ChooseReplacementAttorneys: task.StateCompleted,
+					LifeSustainingTreatment:    task.StateCompleted,
+					Restrictions:               task.StateCompleted,
+					CertificateProvider:        task.StateCompleted,
+					PeopleToNotify:             task.StateCompleted,
+					AddCorrespondent:           task.StateCompleted,
+					ChooseYourSignatory:        task.StateCompleted,
+					CheckYourLpa:               task.StateCompleted,
+					PayForLpa:                  task.PaymentStateCompleted,
+					ConfirmYourIdentity:        task.IdentityStateCompleted,
+					SignTheLpa:                 task.StateCompleted,
+				},
+			},
+			expected: true,
+		},
+	}
+
+	for name, tc := range testcases {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, tc.expected, tc.provided.CompletedAllTasks())
+		})
+	}
+}
+
 func TestProvidedCanChange(t *testing.T) {
 	assert.True(t, (&Provided{}).CanChange())
 	assert.False(t, (&Provided{SignedAt: time.Now()}).CanChange())

internal/donor/donorpage/register.go

@@ -545,7 +545,7 @@ func makeLpaHandle(mux *http.ServeMux, store SessionStore, errorHandler page.Err
 				return
 			}
 
-			if !donor.CanGoTo(lpa, r.URL.String()) {
+			if !path.CanGoTo(lpa) {
 				http.Redirect(w, r, appData.Lang.URL(donor.PathTaskList.Format(lpa.LpaID)), http.StatusFound)
 			}