task_list.go

package donor

import (
	"net/http"

	"github.com/ministryofjustice/opg-go-common/template"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/actor"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/page"
	"github.com/ministryofjustice/opg-modernising-lpa/internal/validation"
)

type taskListData struct {
	App              page.AppData
	Errors           validation.List
	Donor            *actor.DonorProvidedDetails
	Sections         []taskListSection
	EvidenceReceived bool
}

type taskListItem struct {
	Name         string
	Path         string
	State        actor.TaskState
	PaymentState actor.PaymentTask
	Count        int
	Hidden       bool
}

type taskListSection struct {
	Heading string
	Items   []taskListItem
}

func TaskList(tmpl template.Template, evidenceReceivedStore EvidenceReceivedStore) Handler {
	return func(appData page.AppData, w http.ResponseWriter, r *http.Request, donor *actor.DonorProvidedDetails) error {
		evidenceReceived, err := evidenceReceivedStore.Get(r.Context())
		if err != nil {
			return err
		}

		section1 := taskListSection{
			Heading: "fillInTheLpa",
			Items: []taskListItem{
				{
					Name:  "provideYourDetails",
					Path:  page.Paths.YourDetails.Format(donor.LpaID),
					State: donor.Tasks.YourDetails,
				},
				{
					Name:  "chooseYourAttorneys",
					Path:  page.Paths.ChooseAttorneysGuidance.Format(donor.LpaID),
					State: donor.Tasks.ChooseAttorneys,
					Count: donor.Attorneys.Len(),
				},
				{
					Name:  "chooseYourReplacementAttorneys",
					Path:  page.Paths.DoYouWantReplacementAttorneys.Format(donor.LpaID),
					State: donor.Tasks.ChooseReplacementAttorneys,
					Count: donor.ReplacementAttorneys.Len(),
				},
				taskListTypeSpecificStep(donor),
				{
					Name:  "addRestrictionsToTheLpa",
					Path:  page.Paths.Restrictions.Format(donor.LpaID),
					State: donor.Tasks.Restrictions,
				},
				{
					Name:  "chooseYourCertificateProvider",
					Path:  page.Paths.WhatACertificateProviderDoes.Format(donor.LpaID),
					State: donor.Tasks.CertificateProvider,
				},
				{
					Name:  "peopleToNotifyAboutYourLpa",
					Path:  page.Paths.DoYouWantToNotifyPeople.Format(donor.LpaID),
					State: donor.Tasks.PeopleToNotify,
					Count: len(donor.PeopleToNotify),
				},
				{
					Name:   "chooseYourSignatoryAndIndependentWitness",
					Path:   page.Paths.GettingHelpSigning.Format(donor.LpaID),
					State:  donor.Tasks.ChooseYourSignatory,
					Hidden: !donor.Donor.CanSign.IsNo(),
				},
			},
		}

		var sections []taskListSection
		if appData.SupporterData != nil {
			section1.Items = append(section1.Items, taskListItem{
				Name:  "addCorrespondent",
				Path:  page.Paths.AddCorrespondent.Format(donor.LpaID),
				State: donor.Tasks.AddCorrespondent,
			})
			sections = []taskListSection{section1}
		} else {
			section1.Items = append(section1.Items, taskListItem{
				Name:  "checkAndSendToYourCertificateProvider",
				Path:  taskListCheckLpaPath(donor).Format(donor.LpaID),
				State: donor.Tasks.CheckYourLpa,
			})
			sections = []taskListSection{section1, taskListPaymentSection(donor), taskListSignSection(donor)}
		}

		return tmpl(w, &taskListData{
			App:              appData,
			Donor:            donor,
			EvidenceReceived: evidenceReceived,
			Sections:         sections,
		})
	}
}

func taskListTypeSpecificStep(donor *actor.DonorProvidedDetails) taskListItem {
	if donor.Type == actor.LpaTypePersonalWelfare {
		return taskListItem{
			Name:  "lifeSustainingTreatment",
			Path:  page.Paths.LifeSustainingTreatment.Format(donor.LpaID),
			State: donor.Tasks.LifeSustainingTreatment,
		}
	}

	return taskListItem{
		Name:  "chooseWhenTheLpaCanBeUsed",
		Path:  page.Paths.WhenCanTheLpaBeUsed.Format(donor.LpaID),
		State: donor.Tasks.WhenCanTheLpaBeUsed,
	}
}

func taskListCheckLpaPath(donor *actor.DonorProvidedDetails) page.LpaPath {
	if len(donor.Under18ActorDetails()) > 0 {
		return page.Paths.YouCannotSignYourLpaYet
	} else if donor.CertificateProviderSharesDetails() {
		return page.Paths.ConfirmYourCertificateProviderIsNotRelated
	} else {
		return page.Paths.CheckYourLpa
	}
}

func taskListPaymentSection(donor *actor.DonorProvidedDetails) taskListSection {
	var paymentPath page.LpaPath
	switch donor.Tasks.PayForLpa {
	case actor.PaymentTaskDenied:
		paymentPath = page.Paths.FeeDenied
	case actor.PaymentTaskMoreEvidenceRequired:
		paymentPath = page.Paths.UploadEvidence
	default:
		paymentPath = page.Paths.AboutPayment
	}

	return taskListSection{
		Heading: "payForTheLpa",
		Items: []taskListItem{
			{
				Name:         "payForTheLpa",
				Path:         paymentPath.Format(donor.LpaID),
				PaymentState: donor.Tasks.PayForLpa,
			},
		},
	}
}

func taskListSignSection(donor *actor.DonorProvidedDetails) taskListSection {
	var signPath page.LpaPath
	if donor.DonorIdentityConfirmed() {
		signPath = page.Paths.ReadYourLpa
	} else {
		signPath = page.Paths.HowToConfirmYourIdentityAndSign
	}

	return taskListSection{
		Heading: "confirmYourIdentityAndSign",
		Items: []taskListItem{
			{
				Name:  "confirmYourIdentityAndSign",
				Path:  signPath.Format(donor.LpaID),
				State: donor.Tasks.ConfirmYourIdentityAndSign,
			},
		},
	}
}