From 9f111f2a01e00543f9fa27d36943d1d42b7f5337 Mon Sep 17 00:00:00 2001
From: nicholassully <nicholas.sully@digital.justice.gov.uk>
Date: Thu, 8 Aug 2024 13:24:45 +0100
Subject: [PATCH 1/7] pfs-116 FE only for downloading a report

---
 adrs/0002-new-finance-back-end.md        |   2 +-
 internal/api/api_client.go               |  35 ++++-
 internal/api/api_client_test.go          |  53 +++++++
 internal/api/submit_download.go          |  91 +++++++++++
 internal/api/submit_download_test.go     | 119 ++++++++++++++
 internal/model/account_type.go           |  80 ++++++++++
 internal/model/date.go                   |  82 ++++++++++
 internal/model/date_test.go              | 171 +++++++++++++++++++++
 internal/model/debt_type.go              |  44 ++++++
 internal/model/download.go               |  13 ++
 internal/model/error.go                  |  23 +++
 internal/model/journal_type.go           |  50 ++++++
 internal/model/reports_type.go           |  64 ++++++++
 internal/model/schedule_type.go          | 188 +++++++++++++++++++++++
 internal/model/validation.go             |  12 ++
 internal/server/app_vars.go              |   2 +
 internal/server/get_downloads.go         |  14 +-
 internal/server/server.go                |  30 +++-
 internal/server/server_test.go           |   5 +
 internal/server/submit_download.go       |  49 ++++++
 internal/server/submit_download_test.go  |  75 +++++++++
 internal/util/util/translate.go          |  44 ++++++
 internal/util/util/translate_test.go     |  28 ++++
 main.go                                  |   5 +-
 web/assets/main.js                       | 121 +++++++++++++++
 web/template/downloads.gotmpl            | 140 ++++++++++++++++-
 web/template/layout/error-message.gotmpl |   9 ++
 web/template/layout/error-summary.gotmpl |  50 ++++++
 web/template/layout/header.gotmpl        |   3 +
 web/template/layout/main.gotmpl          |   7 +-
 web/template/layout/page.gotmpl          |   2 +-
 31 files changed, 1598 insertions(+), 13 deletions(-)
 create mode 100644 internal/api/api_client_test.go
 create mode 100644 internal/api/submit_download.go
 create mode 100644 internal/api/submit_download_test.go
 create mode 100644 internal/model/account_type.go
 create mode 100644 internal/model/date.go
 create mode 100644 internal/model/date_test.go
 create mode 100644 internal/model/debt_type.go
 create mode 100644 internal/model/download.go
 create mode 100644 internal/model/error.go
 create mode 100644 internal/model/journal_type.go
 create mode 100644 internal/model/reports_type.go
 create mode 100644 internal/model/schedule_type.go
 create mode 100644 internal/model/validation.go
 create mode 100644 internal/server/submit_download.go
 create mode 100644 internal/server/submit_download_test.go
 create mode 100644 internal/util/util/translate.go
 create mode 100644 internal/util/util/translate_test.go
 create mode 100644 web/template/layout/error-message.gotmpl
 create mode 100644 web/template/layout/error-summary.gotmpl
 create mode 100644 web/template/layout/header.gotmpl

diff --git a/adrs/0002-new-finance-back-end.md b/adrs/0002-new-finance-back-end.md
index a342c55..33f3601 100644
--- a/adrs/0002-new-finance-back-end.md
+++ b/adrs/0002-new-finance-back-end.md
@@ -15,7 +15,7 @@ the source of truth for payments moving to us from SOP. We are therefore replaci
 ## Decision
 
 This will be a new Front End service following our established Golang FE pattern. The web pages it serves will have two 
-separate functions: Uploading files for processing, and downloading reports. Reporting will be broken out into a separate
+separate functions: Uploading files for processing, and downloading reports. Reportsing will be broken out into a separate
 microservice, as it has a defined scope and will allow us to provide resources for potentially long-running database queries
 without impacting other services. The architecture for processing files will depend on the file and how coupled the data
 are with existing processes.
diff --git a/internal/api/api_client.go b/internal/api/api_client.go
index fbefcdd..6f89f9e 100644
--- a/internal/api/api_client.go
+++ b/internal/api/api_client.go
@@ -3,6 +3,7 @@ package api
 import (
 	"context"
 	"fmt"
+	"io"
 	"net/http"
 )
 
@@ -21,10 +22,11 @@ func (e ClientError) Error() string {
 	return string(e)
 }
 
-func NewApiClient(httpClient HTTPClient) *ApiClient {
+func NewApiClient(httpClient HTTPClient, siriusUrl string) (*ApiClient, error) {
 	return &ApiClient{
-		http: httpClient,
-	}
+		http:      httpClient,
+		siriusUrl: siriusUrl,
+	}, nil
 }
 
 type HTTPClient interface {
@@ -32,7 +34,8 @@ type HTTPClient interface {
 }
 
 type ApiClient struct {
-	http HTTPClient
+	http      HTTPClient
+	siriusUrl string
 }
 
 type StatusError struct {
@@ -48,3 +51,27 @@ func (e StatusError) Error() string {
 func (e StatusError) Data() interface{} {
 	return e
 }
+
+func (c *ApiClient) newSiriusRequest(ctx Context, method, path string, body io.Reader) (*http.Request, error) {
+	req, err := http.NewRequestWithContext(ctx.Context, method, c.siriusUrl+"/supervision-api/v1"+path, body)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, c := range ctx.Cookies {
+		req.AddCookie(c)
+	}
+
+	req.Header.Add("OPG-Bypass-Membrane", "1")
+	req.Header.Add("X-XSRF-TOKEN", ctx.XSRFToken)
+
+	return req, err
+}
+
+func newStatusError(resp *http.Response) StatusError {
+	return StatusError{
+		Code:   resp.StatusCode,
+		URL:    resp.Request.URL.String(),
+		Method: resp.Request.Method,
+	}
+}
diff --git a/internal/api/api_client_test.go b/internal/api/api_client_test.go
new file mode 100644
index 0000000..02620ec
--- /dev/null
+++ b/internal/api/api_client_test.go
@@ -0,0 +1,53 @@
+package api
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type MockClient struct {
+	DoFunc func(req *http.Request) (*http.Response, error)
+}
+
+var (
+	// GetDoFunc fetches the mock client's `Do` func. Implement this within a test to modify the client's behaviour.
+	GetDoFunc func(req *http.Request) (*http.Response, error)
+)
+
+func (m *MockClient) Do(req *http.Request) (*http.Response, error) {
+	return GetDoFunc(req)
+}
+
+func getContext(cookies []*http.Cookie) Context {
+	return Context{
+		Context:   context.Background(),
+		Cookies:   cookies,
+		XSRFToken: "abcde",
+	}
+}
+
+func TestClientError(t *testing.T) {
+	assert.Equal(t, "message", ClientError("message").Error())
+}
+
+func TestStatusError(t *testing.T) {
+	req, _ := http.NewRequest(http.MethodPost, "/some/url", nil)
+
+	resp := &http.Response{
+		StatusCode: http.StatusTeapot,
+		Request:    req,
+	}
+
+	err := newStatusError(resp)
+
+	assert.Equal(t, "POST /some/url returned 418", err.Error())
+	assert.Equal(t, err, err.Data())
+}
+
+func SetUpTest() *MockClient {
+	mockClient := &MockClient{}
+	return mockClient
+}
diff --git a/internal/api/submit_download.go b/internal/api/submit_download.go
new file mode 100644
index 0000000..c2987d6
--- /dev/null
+++ b/internal/api/submit_download.go
@@ -0,0 +1,91 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/opg-sirius-finance-admin/internal/model"
+	"net/http"
+)
+
+func (c *ApiClient) SubmitDownload(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateField string, dateFromField string, dateToField string, emailField string) error {
+	var body bytes.Buffer
+	var dateTransformed *model.Date
+	var toDateTransformed *model.Date
+	var fromDateTransformed *model.Date
+
+	if dateField != "" {
+		raisedDateFormatted := model.NewDate(dateField)
+		dateTransformed = &raisedDateFormatted
+	}
+
+	if dateToField != "" {
+		startDateFormatted := model.NewDate(dateToField)
+		toDateTransformed = &startDateFormatted
+	}
+
+	if dateFromField != "" {
+		endDateFormatted := model.NewDate(dateFromField)
+		fromDateTransformed = &endDateFormatted
+	}
+
+	err := json.NewEncoder(&body).Encode(model.Download{
+		ReportType:         reportType,
+		ReportJournalType:  reportJournalType,
+		ReportScheduleType: reportScheduleType,
+		ReportAccountType:  reportAccountType,
+		ReportDebtType:     reportDebtType,
+		DateField:          dateTransformed,
+		ToDateField:        toDateTransformed,
+		FromDateField:      fromDateTransformed,
+		Email:              emailField,
+	})
+	if err != nil {
+		return err
+	}
+
+	req, err := c.newSiriusRequest(ctx, http.MethodPost, "/downloads", &body)
+
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusCreated {
+		return nil
+	}
+
+	if resp.StatusCode == http.StatusUnauthorized {
+		return ErrUnauthorized
+	}
+
+	if resp.StatusCode == http.StatusUnprocessableEntity {
+		var v model.ValidationError
+		if err := json.NewDecoder(resp.Body).Decode(&v); err == nil && len(v.Errors) > 0 {
+			return model.ValidationError{Errors: v.Errors}
+		}
+	}
+
+	if resp.StatusCode == http.StatusBadRequest {
+		var badRequests model.BadRequests
+		if err := json.NewDecoder(resp.Body).Decode(&badRequests); err != nil {
+			return err
+		}
+
+		validationErrors := make(model.ValidationErrors)
+		for _, reason := range badRequests.Reasons {
+			innerMap := make(map[string]string)
+			innerMap[reason] = reason
+			validationErrors[reason] = innerMap
+		}
+
+		return model.ValidationError{Errors: validationErrors}
+	}
+
+	return newStatusError(resp)
+}
diff --git a/internal/api/submit_download_test.go b/internal/api/submit_download_test.go
new file mode 100644
index 0000000..922964f
--- /dev/null
+++ b/internal/api/submit_download_test.go
@@ -0,0 +1,119 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/opg-sirius-finance-admin/internal/model"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSubmitDownload(t *testing.T) {
+	mockClient := SetUpTest()
+	client, _ := NewApiClient(mockClient, "http://localhost:3000")
+
+	data := `{
+		"reportType":         "AccountsReceivable",
+		"reportJournalType":  "",
+		"reportScheduleType": "",
+		"reportAccountType":  "BadDebtWriteOffReport",
+		"reportDebtType":     "",
+		"dateField":          "11/05/2024",
+		"dateFromField":      "01/04/2024",
+		"dateToField":        "31/03/2025",
+		"emailField":         "SomeSortOfEmail@example.com",
+	}
+	`
+
+	r := io.NopCloser(bytes.NewReader([]byte(data)))
+
+	GetDoFunc = func(*http.Request) (*http.Response, error) {
+		return &http.Response{
+			StatusCode: 201,
+			Body:       r,
+		}, nil
+	}
+
+	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+	assert.Equal(t, nil, err)
+}
+
+func TestSubmitDownloadUnauthorised(t *testing.T) {
+	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusUnauthorized)
+	}))
+	defer svr.Close()
+
+	client, _ := NewApiClient(http.DefaultClient, svr.URL)
+
+	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+
+	assert.Equal(t, ErrUnauthorized.Error(), err.Error())
+}
+
+func TestSubmitDownloadReturns500Error(t *testing.T) {
+	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer svr.Close()
+
+	client, _ := NewApiClient(http.DefaultClient, svr.URL)
+
+	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+
+	assert.Equal(t, StatusError{
+		Code:   http.StatusInternalServerError,
+		URL:    svr.URL + "/supervision-api/v1/downloads",
+		Method: http.MethodPost,
+	}, err)
+}
+
+func TestSubmitDownloadReturnsBadRequestError(t *testing.T) {
+	mockClient := SetUpTest()
+	client, _ := NewApiClient(mockClient, "http://localhost:3000")
+
+	json := `
+		{"reasons":["StartDate","EndDate"]}
+	`
+
+	r := io.NopCloser(bytes.NewReader([]byte(json)))
+
+	GetDoFunc = func(*http.Request) (*http.Response, error) {
+		return &http.Response{
+			StatusCode: 400,
+			Body:       r,
+		}, nil
+	}
+
+	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+
+	expectedError := model.ValidationError{Message: "", Errors: model.ValidationErrors{"EndDate": map[string]string{"EndDate": "EndDate"}, "StartDate": map[string]string{"StartDate": "StartDate"}}}
+	assert.Equal(t, expectedError, err)
+}
+
+func TestSubmitDownloadReturnsValidationError(t *testing.T) {
+	validationErrors := model.ValidationError{
+		Message: "Validation failed",
+		Errors: map[string]map[string]string{
+			"ReportType": {
+				"required": "Please select a report type",
+			},
+		},
+	}
+	responseBody, _ := json.Marshal(validationErrors)
+	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusUnprocessableEntity)
+		_, _ = w.Write(responseBody)
+	}))
+	defer svr.Close()
+
+	client, _ := NewApiClient(http.DefaultClient, svr.URL)
+
+	err := client.SubmitDownload(getContext(nil), "", "", "", "", "", "", "", "", "")
+	expectedError := model.ValidationError{Message: "", Errors: model.ValidationErrors{"ReportType": map[string]string{"required": "Please select a report type"}}}
+	assert.Equal(t, expectedError, err.(model.ValidationError))
+}
diff --git a/internal/model/account_type.go b/internal/model/account_type.go
new file mode 100644
index 0000000..9ddedd6
--- /dev/null
+++ b/internal/model/account_type.go
@@ -0,0 +1,80 @@
+package model
+
+var ReportAccountTypes = []ReportAccountType{
+	ReportAccountTypeAgedDebt,
+	ReportAccountTypeUnappliedReceipts,
+	ReportAccountTypeCustomerAgeingBuckets,
+	ReportAccountTypeARPaidInvoiceReport,
+	ReportAccountTypePaidInvoiceTransactionLines,
+	ReportAccountTypeTotalReceiptsReport,
+	ReportAccountTypeBadDebtWriteOffReport,
+	ReportAccountTypeFeeAccrual,
+}
+
+type ReportAccountType int
+
+const (
+	ReportAccountTypeUnknown ReportAccountType = iota
+	ReportAccountTypeAgedDebt
+	ReportAccountTypeUnappliedReceipts
+	ReportAccountTypeCustomerAgeingBuckets
+	ReportAccountTypeARPaidInvoiceReport
+	ReportAccountTypePaidInvoiceTransactionLines
+	ReportAccountTypeTotalReceiptsReport
+	ReportAccountTypeBadDebtWriteOffReport
+	ReportAccountTypeFeeAccrual
+)
+
+func (i ReportAccountType) String() string {
+	return i.Key()
+}
+
+func (i ReportAccountType) Translation() string {
+	switch i {
+	case ReportAccountTypeAgedDebt:
+		return "Aged Debt"
+	case ReportAccountTypeUnappliedReceipts:
+		return "Unapplied Receipts"
+	case ReportAccountTypeCustomerAgeingBuckets:
+		return "Customer Ageing Buckets"
+	case ReportAccountTypeARPaidInvoiceReport:
+		return "AR Paid Invoice Report"
+	case ReportAccountTypePaidInvoiceTransactionLines:
+		return "Paid Invoice Transaction Lines"
+	case ReportAccountTypeTotalReceiptsReport:
+		return "Total Receipts Report"
+	case ReportAccountTypeBadDebtWriteOffReport:
+		return "Bad Debt Write-off Report"
+	case ReportAccountTypeFeeAccrual:
+		return "Fee Accrual"
+	default:
+		return ""
+	}
+}
+
+func (i ReportAccountType) Key() string {
+	switch i {
+	case ReportAccountTypeAgedDebt:
+		return "AgedDebt"
+	case ReportAccountTypeUnappliedReceipts:
+		return "UnappliedReceipts"
+	case ReportAccountTypeCustomerAgeingBuckets:
+		return "CustomerAgeingBuckets"
+	case ReportAccountTypeARPaidInvoiceReport:
+		return "ARPaidInvoiceReport"
+	case ReportAccountTypePaidInvoiceTransactionLines:
+		return "PaidInvoiceTransactionLines"
+	case ReportAccountTypeTotalReceiptsReport:
+		return "TotalReceiptsReport"
+	case ReportAccountTypeBadDebtWriteOffReport:
+		return "BadDebtWriteOffReport"
+	case ReportAccountTypeFeeAccrual:
+		return "FeeAccrual"
+	default:
+		return ""
+	}
+}
+
+func (i ReportAccountType) Valid() bool {
+	return i != ReportAccountTypeUnknown
+}
diff --git a/internal/model/date.go b/internal/model/date.go
new file mode 100644
index 0000000..d1e9033
--- /dev/null
+++ b/internal/model/date.go
@@ -0,0 +1,82 @@
+package model
+
+import (
+	"strings"
+	"time"
+)
+
+type Date struct {
+	Time time.Time
+}
+
+func NewDate(d string) Date {
+	t, err := stringToTime(d)
+	if err != nil {
+		panic(err)
+	}
+
+	return Date{Time: t}
+}
+
+func (d Date) Before(d2 Date) bool {
+	return d.Time.Before(d2.Time)
+}
+
+func (d Date) After(d2 Date) bool {
+	return d.Time.After(d2.Time)
+}
+
+func (d Date) String() string {
+	if d.IsNull() {
+		return ""
+	}
+	return d.Time.Format("02/01/2006")
+}
+
+func (d Date) IsNull() bool {
+	nullDate := NewDate("01/01/0001")
+	return d.Time.Equal(nullDate.Time)
+}
+
+func (d *Date) UnmarshalJSON(b []byte) error {
+	t, err := stringToTime(string(b))
+	if err != nil {
+		return err
+	}
+
+	*d = Date{Time: t}
+	return nil
+}
+
+func stringToTime(s string) (time.Time, error) {
+	value := strings.Trim(s, `"`)
+	if value == "" || value == "null" {
+		return time.Time{}, nil
+	}
+
+	value = strings.ReplaceAll(value, `\`, "")
+	supportedFormats := []string{
+		"02/01/2006",
+		"2006-01-02T15:04:05+00:00",
+		"2006-01-02",
+	}
+
+	var t time.Time
+	var err error
+
+	for _, format := range supportedFormats {
+		t, err = time.Parse(format, value)
+		if err != nil {
+			continue
+		}
+		break
+	}
+	if err != nil {
+		return time.Time{}, err
+	}
+	return t, nil
+}
+
+func (d Date) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + d.Time.Format("02\\/01\\/2006") + `"`), nil
+}
diff --git a/internal/model/date_test.go b/internal/model/date_test.go
new file mode 100644
index 0000000..7a8d5fd
--- /dev/null
+++ b/internal/model/date_test.go
@@ -0,0 +1,171 @@
+package model
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"strconv"
+	"testing"
+	"time"
+)
+
+type testJsonDateStruct struct {
+	TestDate Date `json:"testDate"`
+}
+
+func TestNewDate(t *testing.T) {
+	want := Date{Time: time.Date(2020, 12, 31, 0, 0, 0, 0, time.UTC)}
+	assert.Equal(t, want, NewDate("31/12/2020"))
+
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("NewDate should panic with incorrect date format")
+		}
+	}()
+	NewDate("12/31/2020") // wrong format should trigger a panic
+}
+
+func TestDate_Before_And_After(t *testing.T) {
+	tests := []struct {
+		name              string
+		date1             Date
+		date2             Date
+		wantForBeforeTest bool
+		wantForAfterTest  bool
+	}{
+		{
+			name:              "Date1 is before Date2",
+			date1:             NewDate("01/01/2020"),
+			date2:             NewDate("02/01/2020"),
+			wantForBeforeTest: true,
+			wantForAfterTest:  false,
+		},
+		{
+			name:              "Date1 is after Date2",
+			date1:             NewDate("02/01/2020"),
+			date2:             NewDate("01/01/2020"),
+			wantForBeforeTest: false,
+			wantForAfterTest:  true,
+		},
+		{
+			name:              "Date1 is the same as Date2",
+			date1:             NewDate("01/01/2020"),
+			date2:             NewDate("01/01/2020"),
+			wantForBeforeTest: false,
+			wantForAfterTest:  false,
+		},
+		{
+			name:              "Date1 is empty",
+			date1:             Date{},
+			date2:             NewDate("02/01/2020"),
+			wantForBeforeTest: true,
+			wantForAfterTest:  false,
+		},
+		{
+			name:              "Date2 is empty",
+			date1:             NewDate("01/01/2020"),
+			date2:             Date{},
+			wantForBeforeTest: false,
+			wantForAfterTest:  true,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			assert.Equal(t, test.wantForBeforeTest, test.date1.Before(test.date2))
+			assert.Equal(t, test.wantForAfterTest, test.date1.After(test.date2))
+		})
+	}
+}
+
+func TestDate_IsNull(t *testing.T) {
+	tests := []struct {
+		date Date
+		want bool
+	}{
+		{
+			date: NewDate("01/01/2020"),
+			want: false,
+		},
+		{
+			date: NewDate("01/01/0001"),
+			want: true,
+		},
+		{
+			date: Date{},
+			want: true,
+		},
+	}
+	for i, test := range tests {
+		t.Run("Scenario "+strconv.Itoa(i+1), func(t *testing.T) {
+			assert.Equal(t, test.want, test.date.IsNull())
+		})
+	}
+}
+
+func TestDate_MarshalJSON(t *testing.T) {
+	v := testJsonDateStruct{TestDate: NewDate("01/01/2020")}
+	b, err := json.Marshal(v)
+	assert.Nil(t, err)
+	assert.Equal(t, `{"testDate":"01\/01\/2020"}`, string(b))
+}
+
+func TestDate_String(t *testing.T) {
+	tests := []struct {
+		name      string
+		inputDate string
+		want      string
+	}{
+		{
+			name:      "returns correct format for slashers",
+			inputDate: "01/01/2020",
+			want:      "01/01/2020",
+		},
+		{
+			name:      "returns correct format for dashers",
+			inputDate: "2024-10-01",
+			want:      "01/10/2024",
+		},
+		{
+			name:      "returns correct format for date time string",
+			inputDate: "2025-01-02T18:07:10+00:00",
+			want:      "02/01/2025",
+		},
+		{
+			name:      "returns nothing for default date string",
+			inputDate: "01/01/0001",
+			want:      "",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equalf(t, tt.want, NewDate(tt.inputDate).String(), "stringToTime(%v)", tt.inputDate)
+		})
+	}
+}
+
+func TestDate_UnmarshalJSON(t *testing.T) {
+	tests := []struct {
+		json string
+		want string
+	}{
+		{
+			json: `{"testDate":"01\/01\/2020"}`,
+			want: "01/01/2020",
+		},
+		{
+			json: `{"testDate":"01/01/2020"}`,
+			want: "01/01/2020",
+		},
+		{
+			json: `{"testDate":"2020-01-01T20:01:02+00:00"}`,
+			want: "01/01/2020",
+		},
+	}
+	for i, test := range tests {
+		t.Run("Scenario "+strconv.Itoa(i+1), func(t *testing.T) {
+			var v *testJsonDateStruct
+			err := json.Unmarshal([]byte(test.json), &v)
+			assert.Nil(t, err)
+			assert.Equal(t, test.want, v.TestDate.String())
+		})
+	}
+}
diff --git a/internal/model/debt_type.go b/internal/model/debt_type.go
new file mode 100644
index 0000000..51ce2ae
--- /dev/null
+++ b/internal/model/debt_type.go
@@ -0,0 +1,44 @@
+package model
+
+var ReportDebtTypes = []ReportDebtType{
+	ReportDebtTypeFeeChase,
+	ReportDebtTypeFinalFee,
+}
+
+type ReportDebtType int
+
+const (
+	ReportDebtTypeUnknown ReportDebtType = iota
+	ReportDebtTypeFeeChase
+	ReportDebtTypeFinalFee
+)
+
+func (i ReportDebtType) String() string {
+	return i.Key()
+}
+
+func (i ReportDebtType) Translation() string {
+	switch i {
+	case ReportDebtTypeFeeChase:
+		return "Fee Chase"
+	case ReportDebtTypeFinalFee:
+		return "Final Fee"
+	default:
+		return ""
+	}
+}
+
+func (i ReportDebtType) Key() string {
+	switch i {
+	case ReportDebtTypeFeeChase:
+		return "FeeChase"
+	case ReportDebtTypeFinalFee:
+		return "FinalFee"
+	default:
+		return ""
+	}
+}
+
+func (i ReportDebtType) Valid() bool {
+	return i != ReportDebtTypeUnknown
+}
diff --git a/internal/model/download.go b/internal/model/download.go
new file mode 100644
index 0000000..2aad705
--- /dev/null
+++ b/internal/model/download.go
@@ -0,0 +1,13 @@
+package model
+
+type Download struct {
+	ReportType         string `json:"reportType"`
+	ReportJournalType  string `json:"reportJournalType"`
+	ReportScheduleType string `json:"reportScheduleType"`
+	ReportAccountType  string `json:"reportAccountType"`
+	ReportDebtType     string `json:"reportDebtType"`
+	DateField          *Date  `json:"dateField,omitempty"`
+	ToDateField        *Date  `json:"toDateField,omitempty"`
+	FromDateField      *Date  `json:"fromDateField,omitempty"`
+	Email              string `json:"email"`
+}
diff --git a/internal/model/error.go b/internal/model/error.go
new file mode 100644
index 0000000..1776cd7
--- /dev/null
+++ b/internal/model/error.go
@@ -0,0 +1,23 @@
+package model
+
+import (
+	"fmt"
+	"strings"
+)
+
+type BadRequest struct {
+	Field  string `json:"field"`
+	Reason string `json:"reason"`
+}
+
+func (b BadRequest) Error() string {
+	return b.Reason
+}
+
+type BadRequests struct {
+	Reasons []string `json:"reasons"`
+}
+
+func (b BadRequests) Error() string {
+	return fmt.Sprintf("bad requests: %s", strings.Join(b.Reasons, ", "))
+}
diff --git a/internal/model/journal_type.go b/internal/model/journal_type.go
new file mode 100644
index 0000000..dca9d03
--- /dev/null
+++ b/internal/model/journal_type.go
@@ -0,0 +1,50 @@
+package model
+
+var ReportJournalTypes = []ReportJournalType{
+	ReportTypeReceiptTransactions,
+	ReportTypeNonReceiptTransactions,
+	ReportTypeMOTOCardPayments,
+}
+
+type ReportJournalType int
+
+const (
+	ReportTypeUnknown ReportJournalType = iota
+	ReportTypeReceiptTransactions
+	ReportTypeNonReceiptTransactions
+	ReportTypeMOTOCardPayments
+)
+
+func (i ReportJournalType) String() string {
+	return i.Key()
+}
+
+func (i ReportJournalType) Translation() string {
+	switch i {
+	case ReportTypeReceiptTransactions:
+		return "Receipt Transactions"
+	case ReportTypeNonReceiptTransactions:
+		return "Non Receipt Transactions"
+	case ReportTypeMOTOCardPayments:
+		return "Accounts Receivable"
+	default:
+		return ""
+	}
+}
+
+func (i ReportJournalType) Key() string {
+	switch i {
+	case ReportTypeReceiptTransactions:
+		return "ReceiptTransactions"
+	case ReportTypeNonReceiptTransactions:
+		return "NonReceiptTransactions"
+	case ReportTypeMOTOCardPayments:
+		return "AccountsReceivable"
+	default:
+		return ""
+	}
+}
+
+func (i ReportJournalType) Valid() bool {
+	return i != ReportTypeUnknown
+}
diff --git a/internal/model/reports_type.go b/internal/model/reports_type.go
new file mode 100644
index 0000000..d9e5463
--- /dev/null
+++ b/internal/model/reports_type.go
@@ -0,0 +1,64 @@
+package model
+
+var ReportsTypes = []ReportsType{
+	ReportsTypeJournal,
+	ReportsTypeSchedule,
+	ReportsTypeAccountsReceivable,
+	ReportsTypeDebt,
+}
+
+type ReportsType int
+
+const (
+	ReportsTypeUnknown ReportsType = iota
+	ReportsTypeJournal
+	ReportsTypeSchedule
+	ReportsTypeAccountsReceivable
+	ReportsTypeDebt
+)
+
+func (i ReportsType) String() string {
+	return i.Key()
+}
+
+func (i ReportsType) Translation() string {
+	switch i {
+	case ReportsTypeJournal:
+		return "Journal"
+	case ReportsTypeSchedule:
+		return "Schedule"
+	case ReportsTypeAccountsReceivable:
+		return "Accounts Receivable"
+	case ReportsTypeDebt:
+		return "Debt"
+	default:
+		return ""
+	}
+}
+
+func (i ReportsType) Key() string {
+	switch i {
+	case ReportsTypeJournal:
+		return "Journal"
+	case ReportsTypeSchedule:
+		return "Schedule"
+	case ReportsTypeAccountsReceivable:
+		return "AccountsReceivable"
+	case ReportsTypeDebt:
+		return "Debt"
+	default:
+		return ""
+	}
+}
+
+func (i ReportsType) Valid() bool {
+	return i != ReportsTypeUnknown
+}
+
+func (i ReportsType) RequiresDateValidation() bool {
+	switch i {
+	case ReportsTypeJournal:
+		return true
+	}
+	return false
+}
diff --git a/internal/model/schedule_type.go b/internal/model/schedule_type.go
new file mode 100644
index 0000000..d8b7701
--- /dev/null
+++ b/internal/model/schedule_type.go
@@ -0,0 +1,188 @@
+package model
+
+var ReportScheduleTypes = []ReportScheduleType{
+	ReportTypeOnlineCardPayments,
+	ReportOPGBACSTransfer,
+	ReportSupervisionBACSTransfer,
+	ReportDirectDebitPayments,
+	ReportAdFeeInvoices,
+	ReportS2FeeInvoices,
+	ReportS3FeeInvoices,
+	ReportB2FeeInvoices,
+	ReportB3FeeInvoices,
+	ReportSFFeeInvoicesGeneral,
+	ReportSFFeeInvoicesMinimal,
+	ReportSEFeeInvoicesGeneral,
+	ReportSEFeeInvoicesMinimal,
+	ReportSOFeeInvoicesGeneral,
+	ReportSOFeeInvoicesMinimal,
+	ReportADFeeReductions,
+	ReportGeneralManualCredits,
+	ReportMinimalManualCredits,
+	ReportGeneralManualDebits,
+	ReportMinimalManualDebits,
+	ReportADWriteOffs,
+	ReportGeneralWriteOffs,
+	ReportMinimalWriteOffs,
+	ReportADWriteOffReversals,
+	ReportGeneralWriteOffReversals,
+	ReportMinimalWriteOffReversals,
+}
+
+type ReportScheduleType int
+
+const (
+	ReportScheduleTypeUnknown ReportScheduleType = iota
+	ReportTypeOnlineCardPayments
+	ReportOPGBACSTransfer
+	ReportSupervisionBACSTransfer
+	ReportDirectDebitPayments
+	ReportAdFeeInvoices
+	ReportS2FeeInvoices
+	ReportS3FeeInvoices
+	ReportB2FeeInvoices
+	ReportB3FeeInvoices
+	ReportSFFeeInvoicesGeneral
+	ReportSFFeeInvoicesMinimal
+	ReportSEFeeInvoicesGeneral
+	ReportSEFeeInvoicesMinimal
+	ReportSOFeeInvoicesGeneral
+	ReportSOFeeInvoicesMinimal
+	ReportADFeeReductions
+	ReportGeneralManualCredits
+	ReportMinimalManualCredits
+	ReportGeneralManualDebits
+	ReportMinimalManualDebits
+	ReportADWriteOffs
+	ReportGeneralWriteOffs
+	ReportMinimalWriteOffs
+	ReportADWriteOffReversals
+	ReportGeneralWriteOffReversals
+	ReportMinimalWriteOffReversals
+)
+
+func (i ReportScheduleType) String() string {
+	return i.Key()
+}
+
+func (i ReportScheduleType) Translation() string {
+	switch i {
+	case ReportTypeOnlineCardPayments:
+		return "Online Card Payments"
+	case ReportOPGBACSTransfer:
+		return "OPG BACS Transfer"
+	case ReportSupervisionBACSTransfer:
+		return "Supervision BACS transfer"
+	case ReportDirectDebitPayments:
+		return "Direct Debit Payment"
+	case ReportAdFeeInvoices:
+		return "Ad Fee Invoices"
+	case ReportS2FeeInvoices:
+		return "S2 Fee Invoices"
+	case ReportS3FeeInvoices:
+		return "S3 Fee Invoices"
+	case ReportB2FeeInvoices:
+		return "B2 Fee Invoices"
+	case ReportB3FeeInvoices:
+		return "B3 Fee Invoices"
+	case ReportSFFeeInvoicesGeneral:
+		return "SF Fee Invoices (General) "
+	case ReportSFFeeInvoicesMinimal:
+		return "SF Fee Invoices (Minimal)"
+	case ReportSEFeeInvoicesGeneral:
+		return "SE Fee Invoices (General)"
+	case ReportSEFeeInvoicesMinimal:
+		return "SE Fee Invoices (Minimal)"
+	case ReportSOFeeInvoicesGeneral:
+		return "SO Fee Invoices (General)"
+	case ReportSOFeeInvoicesMinimal:
+		return "SO Fee Invoices (Minimal)"
+	case ReportADFeeReductions:
+		return "AD Fee Reductions"
+	case ReportGeneralManualCredits:
+		return "General Manual Credits"
+	case ReportMinimalManualCredits:
+		return "Minimal Manual Credits"
+	case ReportGeneralManualDebits:
+		return "General Manual Debits"
+	case ReportMinimalManualDebits:
+		return "Minimal Manual Debits"
+	case ReportADWriteOffs:
+		return "AD Write-offs"
+	case ReportGeneralWriteOffs:
+		return "General Write-offs"
+	case ReportMinimalWriteOffs:
+		return "Minimal Write-offs"
+	case ReportADWriteOffReversals:
+		return "AD Write-off Reversals"
+	case ReportGeneralWriteOffReversals:
+		return "General Write-off Reversals"
+	case ReportMinimalWriteOffReversals:
+		return "Minimal Write-off Reversals"
+	default:
+		return ""
+	}
+}
+
+func (i ReportScheduleType) Key() string {
+	switch i {
+	case ReportTypeOnlineCardPayments:
+		return "OnlineCardPayments"
+	case ReportOPGBACSTransfer:
+		return "OPGBACSTransfer"
+	case ReportSupervisionBACSTransfer:
+		return "SupervisionBACSTransfer"
+	case ReportDirectDebitPayments:
+		return "DirectDebitPayment"
+	case ReportAdFeeInvoices:
+		return "AdFeeInvoices"
+	case ReportS2FeeInvoices:
+		return "S2FeeInvoices"
+	case ReportS3FeeInvoices:
+		return "S3FeeInvoices"
+	case ReportB2FeeInvoices:
+		return "B2FeeInvoices"
+	case ReportB3FeeInvoices:
+		return "B3FeeInvoices"
+	case ReportSFFeeInvoicesGeneral:
+		return "SFFeeInvoicesGeneral "
+	case ReportSFFeeInvoicesMinimal:
+		return "SFFeeInvoicesMinimal"
+	case ReportSEFeeInvoicesGeneral:
+		return "SEFeeInvoicesGeneral"
+	case ReportSEFeeInvoicesMinimal:
+		return "SEFeeInvoicesMinimal"
+	case ReportSOFeeInvoicesGeneral:
+		return "SOFeeInvoicesGeneral"
+	case ReportSOFeeInvoicesMinimal:
+		return "SOFeeInvoicesMinimal"
+	case ReportADFeeReductions:
+		return "ADFeeReductions"
+	case ReportGeneralManualCredits:
+		return "GeneralManualCredits"
+	case ReportMinimalManualCredits:
+		return "MinimalManualCredits"
+	case ReportGeneralManualDebits:
+		return "GeneralManualDebits"
+	case ReportMinimalManualDebits:
+		return "MinimalManualDebits"
+	case ReportADWriteOffs:
+		return "ADWrite-offs"
+	case ReportGeneralWriteOffs:
+		return "GeneralWrite-offs"
+	case ReportMinimalWriteOffs:
+		return "MinimalWriteOffs"
+	case ReportADWriteOffReversals:
+		return "ADWriteOffReversals"
+	case ReportGeneralWriteOffReversals:
+		return "GeneralWriteOffReversals"
+	case ReportMinimalWriteOffReversals:
+		return "MinimalWriteOffReversals"
+	default:
+		return ""
+	}
+}
+
+func (i ReportScheduleType) Valid() bool {
+	return i != ReportScheduleTypeUnknown
+}
diff --git a/internal/model/validation.go b/internal/model/validation.go
new file mode 100644
index 0000000..18965f4
--- /dev/null
+++ b/internal/model/validation.go
@@ -0,0 +1,12 @@
+package model
+
+type ValidationErrors map[string]map[string]string
+
+type ValidationError struct {
+	Message string
+	Errors  ValidationErrors `json:"validation_errors"`
+}
+
+func (ve ValidationError) Error() string {
+	return ve.Message
+}
diff --git a/internal/server/app_vars.go b/internal/server/app_vars.go
index 7792f03..e60c100 100644
--- a/internal/server/app_vars.go
+++ b/internal/server/app_vars.go
@@ -1,6 +1,7 @@
 package server
 
 import (
+	"github.com/opg-sirius-finance-admin/internal/model"
 	"net/http"
 	"net/url"
 )
@@ -10,6 +11,7 @@ type AppVars struct {
 	XSRFToken       string
 	Tabs            []Tab
 	EnvironmentVars EnvironmentVars
+	Errors          model.ValidationErrors
 	Error           string
 }
 
diff --git a/internal/server/get_downloads.go b/internal/server/get_downloads.go
index 7aff9f4..7a45af9 100644
--- a/internal/server/get_downloads.go
+++ b/internal/server/get_downloads.go
@@ -1,10 +1,16 @@
 package server
 
 import (
+	"github.com/opg-sirius-finance-admin/internal/model"
 	"net/http"
 )
 
 type GetDownloadsVars struct {
+	ReportsTypes        *[]model.ReportsType
+	ReportJournalTypes  *[]model.ReportJournalType
+	ReportScheduleTypes *[]model.ReportScheduleType
+	ReportAccountTypes  *[]model.ReportAccountType
+	ReportDebtTypes     *[]model.ReportDebtType
 	AppVars
 }
 
@@ -13,7 +19,13 @@ type GetDownloadsHandler struct {
 }
 
 func (h *GetDownloadsHandler) render(v AppVars, w http.ResponseWriter, r *http.Request) error {
-	data := GetDownloadsVars{v}
+	data := GetDownloadsVars{
+		&model.ReportsTypes,
+		&model.ReportJournalTypes,
+		&model.ReportScheduleTypes,
+		&model.ReportAccountTypes,
+		&model.ReportDebtTypes,
+		v}
 	data.selectTab("downloads")
 	return h.execute(w, r, data)
 }
diff --git a/internal/server/server.go b/internal/server/server.go
index 2564989..d623966 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -3,14 +3,19 @@ package server
 import (
 	"github.com/ministryofjustice/opg-go-common/securityheaders"
 	"github.com/ministryofjustice/opg-go-common/telemetry"
+	"github.com/opg-sirius-finance-admin/internal/api"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"html/template"
 	"io"
 	"log/slog"
 	"net/http"
+	"net/url"
+	"strconv"
 )
 
-type ApiClient interface{}
+type ApiClient interface {
+	SubmitDownload(api.Context, string, string, string, string, string, string, string, string, string) error
+}
 
 type router interface {
 	Client() ApiClient
@@ -35,6 +40,8 @@ func New(logger *slog.Logger, client ApiClient, templates map[string]*template.T
 	handleMux("GET /uploads", &GetUploadsHandler{&route{client: client, tmpl: templates["uploads.gotmpl"], partial: "uploads"}})
 	handleMux("GET /annual-invoicing-letters", &GetAnnualInvoicingLettersHandler{&route{client: client, tmpl: templates["annual_invoicing_letters.gotmpl"], partial: "annual-invoicing-letters"}})
 
+	handleMux("POST /downloads", &SubmitDownloadHandler{&route{client: client, tmpl: templates["downloads.gotmpl"], partial: "error-summary"}})
+
 	mux.Handle("/health-check", healthCheck())
 
 	static := http.FileServer(http.Dir(envVars.WebDir + "/static"))
@@ -44,3 +51,24 @@ func New(logger *slog.Logger, client ApiClient, templates map[string]*template.T
 
 	return otelhttp.NewHandler(http.StripPrefix(envVars.Prefix, securityheaders.Use(mux)), "supervision-finance-admin")
 }
+
+func getContext(r *http.Request) api.Context {
+	token := ""
+
+	if r.Method == http.MethodGet {
+		if cookie, err := r.Cookie("XSRF-TOKEN"); err == nil {
+			token, _ = url.QueryUnescape(cookie.Value)
+		}
+	} else {
+		token = r.FormValue("xsrfToken")
+	}
+
+	clientId, _ := strconv.Atoi(r.PathValue("clientId"))
+
+	return api.Context{
+		Context:   r.Context(),
+		Cookies:   r.Cookies(),
+		XSRFToken: token,
+		ClientId:  clientId,
+	}
+}
diff --git a/internal/server/server_test.go b/internal/server/server_test.go
index 0946243..adfcd01 100644
--- a/internal/server/server_test.go
+++ b/internal/server/server_test.go
@@ -1,6 +1,7 @@
 package server
 
 import (
+	"github.com/opg-sirius-finance-admin/internal/api"
 	"io"
 	"net/http"
 )
@@ -49,3 +50,7 @@ func (r *mockRoute) execute(w http.ResponseWriter, req *http.Request, data any)
 type mockApiClient struct {
 	error error //nolint:golint,unused
 }
+
+func (m mockApiClient) SubmitDownload(context api.Context, s string, s2 string, s3 string, s4 string, s5 string, s6 string, s7 string, s8 string, s9 string) error {
+	return m.error
+}
diff --git a/internal/server/submit_download.go b/internal/server/submit_download.go
new file mode 100644
index 0000000..65a2e5e
--- /dev/null
+++ b/internal/server/submit_download.go
@@ -0,0 +1,49 @@
+package server
+
+import (
+	"errors"
+	"github.com/opg-sirius-finance-admin/internal/api"
+	"github.com/opg-sirius-finance-admin/internal/model"
+	"github.com/opg-sirius-finance-admin/internal/util/util"
+	"net/http"
+)
+
+type SubmitDownloadHandler struct {
+	router
+}
+
+func (h *SubmitDownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Request) error {
+	ctx := getContext(r)
+
+	var (
+		reportType         = r.PostFormValue("reportType")
+		reportJournalType  = r.PostFormValue("reportJournalType")
+		reportScheduleType = r.PostFormValue("reportScheduleType")
+		reportAccountType  = r.PostFormValue("reportAccountType")
+		reportDebtType     = r.PostFormValue("reportDebtType")
+		dateField          = r.PostFormValue("dateField")
+		dateFromField      = r.PostFormValue("dateFromField")
+		dateToField        = r.PostFormValue("dateToField")
+		emailField         = r.PostFormValue("emailField")
+	)
+
+	err := h.Client().SubmitDownload(ctx, reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateField, dateFromField, dateToField, emailField)
+
+	if err != nil {
+		var (
+			valErr model.ValidationError
+			stErr  api.StatusError
+		)
+		if errors.As(err, &valErr) {
+			data := AppVars{Errors: util.RenameErrors(valErr.Errors)}
+			w.WriteHeader(http.StatusUnprocessableEntity)
+			err = h.execute(w, r, data)
+		} else if errors.As(err, &stErr) {
+			data := AppVars{Error: stErr.Error()}
+			w.WriteHeader(stErr.Code)
+			err = h.execute(w, r, data)
+		}
+	}
+
+	return err
+}
diff --git a/internal/server/submit_download_test.go b/internal/server/submit_download_test.go
new file mode 100644
index 0000000..0154d91
--- /dev/null
+++ b/internal/server/submit_download_test.go
@@ -0,0 +1,75 @@
+package server
+
+import (
+	"github.com/opg-sirius-finance-admin/internal/model"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func TestSubmitManualInvoiceSuccess(t *testing.T) {
+	form := url.Values{
+		"reportType":         {"AccountsReceivable"},
+		"reportJournalType":  {""},
+		"reportScheduleType": {""},
+		"reportAccountType":  {"BadDebtWriteOffReport"},
+		"reportDebtType":     {""},
+		"dateField":          {"11/05/2024"},
+		"dateFromField":      {"01/04/2024"},
+		"dateToField":        {"31/03/2025"},
+		"emailField":         {"SomeSortOfEmail@example.com"},
+	}
+
+	client := mockApiClient{}
+	ro := &mockRoute{client: client}
+
+	w := httptest.NewRecorder()
+	r, _ := http.NewRequest(http.MethodPost, "/download", strings.NewReader(form.Encode()))
+	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	r.SetPathValue("clientId", "1")
+
+	appVars := AppVars{
+		Path: "/download",
+	}
+
+	appVars.EnvironmentVars.Prefix = "prefix"
+
+	sut := SubmitDownloadHandler{ro}
+
+	err := sut.render(appVars, w, r)
+
+	assert.Nil(t, err)
+}
+
+func TestSubmitDownloadValidationErrors(t *testing.T) {
+	assert := assert.New(t)
+	client := &mockApiClient{}
+	ro := &mockRoute{client: client}
+
+	validationErrors := model.ValidationErrors{
+		"ReportType": {
+			"ReportType": "Please select a report type",
+		},
+	}
+
+	client.error = model.ValidationError{
+		Errors: validationErrors,
+	}
+
+	w := httptest.NewRecorder()
+	r, _ := http.NewRequest(http.MethodPost, "/invoices", nil)
+	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	r.SetPathValue("clientId", "1")
+
+	appVars := AppVars{
+		Path: "/add",
+	}
+
+	sut := SubmitDownloadHandler{ro}
+	err := sut.render(appVars, w, r)
+	assert.Nil(err)
+	assert.Equal("422 Unprocessable Entity", w.Result().Status)
+}
diff --git a/internal/util/util/translate.go b/internal/util/util/translate.go
new file mode 100644
index 0000000..3d56b9a
--- /dev/null
+++ b/internal/util/util/translate.go
@@ -0,0 +1,44 @@
+package util
+
+import "github.com/opg-sirius-finance-admin/internal/model"
+
+type pair struct {
+	k string
+	v string
+}
+
+var validationMappings = map[string]map[string]pair{
+	"ReportType": {
+		"required": pair{"ReportType", "Please select a report type"},
+	},
+	"ReportSubType": {
+		"required": pair{"ReportSubType", "Please select a report to download"},
+	},
+	"Date": {
+		"Date":             pair{"Date", "Please select the report date"},
+		"date-in-the-past": pair{"Date", "The report date must be today or in the past"},
+	},
+	"FromDate": {
+		"FromDate": pair{"FromDate", "From date must be before to date"},
+	},
+	"ToDate": {
+		"ToDate": pair{"ToDate", "To date must be after from date"},
+	},
+}
+
+func RenameErrors(siriusError model.ValidationErrors) model.ValidationErrors {
+	mappedErrors := model.ValidationErrors{}
+	for fieldName, value := range siriusError {
+		for errorType, errorMessage := range value {
+			err := make(map[string]string)
+			if mapping, ok := validationMappings[fieldName][errorType]; ok {
+				err[errorType] = mapping.v
+				mappedErrors[mapping.k] = err
+			} else {
+				err[errorType] = errorMessage
+				mappedErrors[fieldName] = err
+			}
+		}
+	}
+	return mappedErrors
+}
diff --git a/internal/util/util/translate_test.go b/internal/util/util/translate_test.go
new file mode 100644
index 0000000..f837072
--- /dev/null
+++ b/internal/util/util/translate_test.go
@@ -0,0 +1,28 @@
+package util
+
+import (
+	"github.com/opg-sirius-finance-admin/internal/model"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestRenameErrors(t *testing.T) {
+	siriusErrors := model.ValidationErrors{
+		"ReportType": map[string]string{"required": ""},
+		"Date":       map[string]string{"Date": ""},
+	}
+	expected := model.ValidationErrors{
+		"ReportType": map[string]string{"required": "Please select a report type"},
+		"Date":       map[string]string{"Date": "Please select the report date"},
+	}
+
+	assert.Equal(t, expected, RenameErrors(siriusErrors))
+}
+
+func TestRenameErrors_default(t *testing.T) {
+	siriusErrors := model.ValidationErrors{
+		"x": map[string]string{"y": "z"},
+	}
+
+	assert.Equal(t, siriusErrors, RenameErrors(siriusErrors))
+}
diff --git a/main.go b/main.go
index 3c3f6bb..fc8c479 100644
--- a/main.go
+++ b/main.go
@@ -39,7 +39,10 @@ func run(ctx context.Context, logger *slog.Logger) error {
 	}
 
 	envVars := server.NewEnvironmentVars()
-	client := api.NewApiClient(http.DefaultClient)
+	client, err := api.NewApiClient(http.DefaultClient, envVars.SiriusURL)
+	if err != nil {
+		return err
+	}
 	templates := createTemplates(envVars)
 
 	s := &http.Server{
diff --git a/web/assets/main.js b/web/assets/main.js
index 9440380..1e47943 100644
--- a/web/assets/main.js
+++ b/web/assets/main.js
@@ -9,3 +9,124 @@ initAll();
 window.htmx = htmx
 htmx.logAll();
 htmx.config.responseHandling = [{code:".*", swap: true}]
+
+function disableFormInputs() {
+    document.querySelector('#report-journal-type').setAttribute("disabled", "true")
+    document.querySelector('#report-schedule-type').setAttribute("disabled", "true")
+    document.querySelector('#report-account-type').setAttribute("disabled", "true")
+    document.querySelector('#report-debt-type').setAttribute("disabled", "true")
+    document.querySelector('#date-field').setAttribute("disabled", "true")
+    document.querySelector('#date-from-field').setAttribute("disabled", "true")
+    document.querySelector('#date-to-field').setAttribute("disabled", "true")
+    document.querySelector('#email-field').setAttribute("disabled", "true")
+}
+
+// adding event listeners inside the onLoad function will ensure they are re-added to partial content when loaded back in
+htmx.onLoad(content => {
+    initAll();
+
+    if (document.getElementById('reports-type')) {
+        htmx.findAll("#reports-type").forEach((element) => {
+            element.addEventListener("change", function() {
+                const elements = document.querySelectorAll('[id$="-field-input"]');
+                elements.forEach(element => {
+                    htmx.addClass(element, 'hide');
+                });
+                disableFormInputs();
+                const form = document.querySelector('form');
+                const reportTypeSelect = document.getElementById('reports-type');
+                const reportTypeSelectValue = reportTypeSelect.value
+
+                form.reset();
+                reportTypeSelect.value =  reportTypeSelectValue
+
+                switch (reportTypeSelect.value) {
+                    case "Journal":
+                        document.querySelector('#report-journal-type').removeAttribute("disabled");
+                        document.querySelector('#date-field').removeAttribute("disabled");
+                        htmx.removeClass(htmx.find("#journal-types-field-input"), "hide")
+                        htmx.removeClass(htmx.find("#date-field-input"), "hide")
+                        break;
+                    case "Schedule":
+                        document.querySelector('#report-schedule-type').removeAttribute("disabled");
+                        document.querySelector('#date-field').removeAttribute("disabled");
+                        htmx.removeClass(htmx.find("#schedule-types-field-input"), "hide")
+                        htmx.removeClass(htmx.find("#date-field-input"), "hide")
+                        break;
+                    case "AccountsReceivable":
+                        document.querySelector('#report-account-type').removeAttribute("disabled")
+                        htmx.removeClass(htmx.find("#account-types-field-input"), "hide")
+                        break;
+                    case "Debt":
+                        document.querySelector('#report-debt-type').removeAttribute("disabled")
+                        htmx.removeClass(htmx.find("#debt-types-field-input"), "hide")
+                        break;
+                    default:
+                        break;
+                }
+            }, false)
+        });
+
+        document.getElementById('report-account-type').addEventListener('change', function () {
+            const form = document.querySelector('form');
+            const reportTypeSelect = document.getElementById('reports-type');
+            const reportTypeSelectValue = reportTypeSelect.value
+            const reportAccountTypeSelectValue = this.value
+            disableFormInputs();
+            document.querySelector('#report-account-type').removeAttribute("disabled");
+
+            form.reset();
+            reportTypeSelect.value =  reportTypeSelectValue
+            this.value = reportAccountTypeSelectValue
+
+            switch (this.value) {
+                case "AgedDebt":
+                case "UnappliedReceipts":
+                case "CustomerAgeingBuckets":
+                    document.querySelector('#date-field').removeAttribute("disabled");
+                    htmx.addClass(htmx.find("#date-to-field-input"), "hide")
+                    htmx.addClass(htmx.find("#email-field-input"), "hide")
+                    htmx.addClass(htmx.find("#date-from-field-input"), "hide")
+                    htmx.removeClass(htmx.find("#date-field-input"), "hide")
+                    break;
+                case "ARPaidInvoiceReport":
+                case "PaidInvoiceTransactionLines":
+                case "TotalReceiptsReport":
+                case "BadDebtWriteOffReport":
+                    document.querySelector('#date-to-field').removeAttribute("disabled");
+                    document.querySelector('#email-field').removeAttribute("disabled");
+                    document.querySelector('#date-from-field').removeAttribute("disabled");
+                    htmx.addClass(htmx.find("#date-field-input"), "hide")
+                    htmx.removeClass(htmx.find("#date-to-field-input"), "hide")
+                    htmx.removeClass(htmx.find("#email-field-input"), "hide")
+                    htmx.removeClass(htmx.find("#date-from-field-input"), "hide")
+                    break;
+                case "FeeAccrual":
+                    htmx.addClass(htmx.find("#date-field-input"), "hide")
+                    htmx.addClass(htmx.find("#date-to-field-input"), "hide")
+                    htmx.addClass(htmx.find("#email-field-input"), "hide")
+                    htmx.addClass(htmx.find("#date-from-field-input"), "hide")
+                    break;
+                default:
+                    break;
+            }
+        })
+    }
+
+    // validation errors are loaded in as a partial, with oob-swaps for the field error messages,
+    // but classes need to be applied to each form group that appears in the summary
+    const errorSummary = htmx.find("#error-summary");
+    if (errorSummary) {
+        const errors = [];
+        errorSummary.querySelectorAll(".govuk-link").forEach((element) => {
+            errors.push(element.getAttribute("href"));
+        });
+        htmx.findAll(".govuk-form-group").forEach((element) => {
+            if (errors.includes(`#${element.id}`)) {
+                element.classList.add("govuk-form-group--error");
+            } else {
+                element.classList.remove("govuk-form-group--error");
+            }
+        })
+    }
+});
\ No newline at end of file
diff --git a/web/template/downloads.gotmpl b/web/template/downloads.gotmpl
index 01c4722..5ba3d99 100644
--- a/web/template/downloads.gotmpl
+++ b/web/template/downloads.gotmpl
@@ -4,9 +4,143 @@
 {{ define "main-content" }}
     {{ block "downloads" .Data }}
         {{ template "navigation" . }}
-        <div>
-            <div class="govuk-grid-row">
-                <div class="govuk-grid-column-full">
+        <div id="error-summary"></div>
+        <div class="govuk-grid-row sirius-admin">
+            <div class="govuk-grid-column-full">
+                <h1 class="govuk-heading-m  govuk-!-margin-bottom-1">Download a report</h1>
+                <div class="govuk-grid-row">
+                    <form
+                            class="govuk-grid-column-one-third"
+                            method="post"
+                            hx-post="{{ prefix "/downloads" }}"
+                            hx-target="#error-summary"
+                    >
+                        <div class="govuk-form-group">
+
+                            <div class="govuk-form-group" id="f-ReportType">
+                                <label class="govuk-label" for="reports-type">
+                                    Select a report type
+                                    <span id="error-message__ReportType"></span>
+                                </label>
+                                <select data-cy="report-type" class="govuk-select" id="reports-type" name="reportType">
+                                    <option value=""></option>
+                                    {{ range .ReportsTypes }}
+                                        <option value="{{ .Key }}" id="{{.Key}}">{{.Translation}}</option>
+                                    {{end}}
+                                </select>
+                            </div>
+
+                            <div class="hide" id="journal-types-field-input">
+                                <div class="govuk-form-group" id="f-ReportSubType">
+                                    <label class="govuk-label" for="report-journal-type">
+                                        Select a report
+                                        <span id="error-message__ReportSubType"></span>
+                                    </label>
+                                    <select disabled data-cy="report-journal-type" class="govuk-select" id="report-journal-type" name="reportJournalType">
+                                        <option value=""></option>
+                                        {{ range .ReportJournalTypes }}
+                                            <option value="{{ .Key }}" id="{{.Key}}">{{.Translation}}</option>
+                                        {{end}}
+                                    </select>
+                                </div>
+                            </div>
+
+                            <div class="hide" id="schedule-types-field-input">
+                                <div class="govuk-form-group" id="f-ReportSubType">
+                                    <label class="govuk-label" for="report-schedule-type">
+                                        Select a report
+                                        <span id="error-message__ReportSubType"></span>
+                                    </label>
+                                    <select disabled data-cy="report-schedule-type" class="govuk-select" id="report-schedule-type" name="reportScheduleType">
+                                        <option value=""></option>
+                                        {{ range .ReportScheduleTypes }}
+                                            <option value="{{ .Key }}" id="{{.Key}}">{{.Translation}}</option>
+                                        {{end}}
+                                    </select>
+                                </div>
+                            </div>
+
+                            <div class="hide" id="account-types-field-input">
+                                <div class="govuk-form-group" id="f-ReportSubType">
+                                    <label class="govuk-label" for="report-account-type">
+                                        Select a report
+                                        <span id="error-message__ReportSubType"></span>
+                                    </label>
+                                    <select disabled class="govuk-select" id="report-account-type" name="reportAccountType">
+                                        <option value=""></option>
+                                        {{ range .ReportAccountTypes }}
+                                            <option value="{{ .Key }}" id="{{.Key}}">{{.Translation}}</option>
+                                        {{end}}
+                                    </select>
+                                </div>
+                            </div>
+
+                            <div class="hide" id="debt-types-field-input">
+                                <div class="govuk-form-group" id="f-ReportSubType">
+                                    <label class="govuk-label" for="report-debt-type">
+                                        Select a report
+                                        <span id="error-message__ReportSubType"></span>
+                                    </label>
+                                    <select disabled class="govuk-select" id="report-debt-type" name="reportDebtType">
+                                        <option value=""></option>
+                                        {{ range .ReportDebtTypes }}
+                                            <option value="{{ .Key }}" id="{{.Key}}">{{.Translation}}</option>
+                                        {{end}}
+                                    </select>
+                                </div>
+                            </div>
+
+                            <div class="hide govuk-!-margin-top-5" id="date-field-input">
+                                <div class="govuk-form-group" id="f-Date">
+                                    <label class="govuk-label" for="date-field">
+                                        Date
+                                        <span id="error-message__Date"></span>
+                                    </label>
+                                    <input disabled class="govuk-input govuk-input--width-10" id="date-field" name="dateField" type="date">
+                                </div>
+                            </div>
+
+                            <div class="hide govuk-!-margin-top-5" id="date-from-field-input">
+                                <div class="govuk-form-group" id="f-FromDate">
+                                    <label class="govuk-label" for="date-from-field">
+                                        Date from
+                                        <span id="error-message__FromDate"></span>
+                                    </label>
+                                    <input disabled class="govuk-input govuk-input--width-10" id="date-from-field" name="dateFromField" type="date">
+                                </div>
+                            </div>
+
+                            <div class="hide govuk-!-margin-top-5" id="date-to-field-input">
+                                <div class="govuk-form-group" id="f-ToDate">
+                                    <label class="govuk-label" for="date-to-field">
+                                        Date to
+                                        <span id="error-message__ToDate"></span>
+                                    </label>
+                                    <input disabled class="govuk-input govuk-input--width-10" id="date-to-field" name="dateToField" type="date">
+                                </div>
+                            </div>
+
+                            <div class="hide govuk-!-margin-top-5" id="email-field-input">
+                                <div class="govuk-form-group" id="f-Email">
+                                    <label class="govuk-label" for="email-field">
+                                        Email address
+                                        <span id="error-message__Email"></span>
+                                    </label>
+                                    <div id="email-hint" class="govuk-hint">
+                                        We’ll only use this to send you the finished report
+                                    </div>
+                                    <input disabled class="govuk-input" id="email-field" name="emailField" type="email" spellcheck="false" aria-describedby="email-hint" autocomplete="email">
+                                </div>
+                            </div>
+
+                            <div class="govuk-button-group govuk-!-margin-top-5">
+                                <button class="govuk-button" data-module="govuk-button">
+                                    Download report
+                                </button>
+                                <a class="govuk-link" href="{{ prefix "/downloads" }}">Cancel</a>
+                            </div>
+                        </div>
+                    </form>
                 </div>
             </div>
         </div>
diff --git a/web/template/layout/error-message.gotmpl b/web/template/layout/error-message.gotmpl
new file mode 100644
index 0000000..3886828
--- /dev/null
+++ b/web/template/layout/error-message.gotmpl
@@ -0,0 +1,9 @@
+{{ define "error-message" }}
+    {{ if . }}
+        {{ range $type, $error := . }}
+            <p id="name-error{{ if $type}}-{{ $type }}{{ end }}" class="govuk-error-message">
+              <span class="govuk-visually-hidden">Error:</span> {{ $error }}
+            </p>
+        {{ end }}
+    {{ end }}
+{{ end }}
diff --git a/web/template/layout/error-summary.gotmpl b/web/template/layout/error-summary.gotmpl
new file mode 100644
index 0000000..3025be2
--- /dev/null
+++ b/web/template/layout/error-summary.gotmpl
@@ -0,0 +1,50 @@
+{{ define "error-summary" }}
+    <div id="error-summary">
+        {{ if .Errors }}
+            <div
+                    class="govuk-error-summary"
+                    aria-labelledby="error-summary-title"
+                    role="alert"
+                    tabindex="-1"
+                    data-module="govuk-error-summary">
+                <h2 class="govuk-error-summary__title" id="error-summary-title">
+                    There is a problem
+                </h2>
+                <div class="govuk-error-summary__body">
+                    <ul class="govuk-list govuk-error-summary__list">
+                        {{ range $k, $v := .Errors }}
+                            {{ range $v }}
+                                <li><a class="govuk-link" href="#f-{{ $k }}">{{ . }}</a></li>
+                            {{ end }}
+                        {{ end }}
+                    </ul>
+                </div>
+            </div>
+        {{ end }}
+        {{ if .Error }}
+            <div
+                    class="govuk-error-summary"
+                    aria-labelledby="error-summary-title"
+                    role="alert"
+                    tabindex="-1"
+                    data-module="govuk-error-summary">
+                <h2 class="govuk-error-summary__title" id="error-summary-title">
+                    There is a problem
+                </h2>
+                <div class="govuk-error-summary__body">
+                    {{ .Error }}
+                </div>
+            </div>
+        {{ end }}
+    </div>
+
+    {{ range $k, $v := .Errors }}
+        <span id="error-message__{{$k}}" hx-swap-oob="true">
+                {{ range $type, $error := $v }}
+                    <p id="name-error{{ if $type}}-{{ $type }}{{ end }}" class="govuk-error-message">
+                      <span class="govuk-visually-hidden">Error:</span> {{ $error }}
+                    </p>
+                {{ end }}
+        </span>
+    {{ end }}
+{{ end }}
diff --git a/web/template/layout/header.gotmpl b/web/template/layout/header.gotmpl
new file mode 100644
index 0000000..cb89a4f
--- /dev/null
+++ b/web/template/layout/header.gotmpl
@@ -0,0 +1,3 @@
+{{ define "header" }}
+  <sirius-header></sirius-header>
+{{ end }}
diff --git a/web/template/layout/main.gotmpl b/web/template/layout/main.gotmpl
index a294850..8c44065 100644
--- a/web/template/layout/main.gotmpl
+++ b/web/template/layout/main.gotmpl
@@ -1,7 +1,12 @@
 {{- /*gotype: github.com/ministryofjustice/opg-sirius-supervision-finance-admin/internal/server.PageData*/ -}}
 {{ define "main" }}
-    <div id="main-container" class="govuk-width-container app-width-container">
+    <div id="main-container" class="govuk-!-margin-left-3" >
         <main class="govuk-main-wrapper app-main-class" role="main">
+            <div class="govuk-grid-row">
+                <div class="govuk-grid-column-full">
+                    <h2 class="govuk-heading-l">Management information</h2>
+                </div>
+            </div>
             <div id="main-content">
                 {{ block "main-content" . }}{{ end }}
             </div>
diff --git a/web/template/layout/page.gotmpl b/web/template/layout/page.gotmpl
index 1246741..b7f79b9 100644
--- a/web/template/layout/page.gotmpl
+++ b/web/template/layout/page.gotmpl
@@ -21,7 +21,7 @@
     </head>
 
     <body class="govuk-template__body">
-      <sirius-header></sirius-header>
+      {{ template "header" . }}
 
       {{ block "main" . }}{{ end }}
 

From d5c30101e56159c9a6d2dff602abce3fb8412084 Mon Sep 17 00:00:00 2001
From: nicholassully <nicholas.sully@digital.justice.gov.uk>
Date: Mon, 12 Aug 2024 14:00:16 +0100
Subject: [PATCH 2/7] pfs-116 changing post to a get

---
 adrs/0002-new-finance-back-end.md             |  2 +-
 internal/api/api_client.go                    | 16 +++---
 .../api/{submit_download.go => download.go}   |  4 +-
 ...bmit_download_test.go => download_test.go} | 24 ++++-----
 internal/model/journal_type.go                |  6 ---
 internal/model/schedule_type.go               |  6 +++
 internal/server/download.go                   | 50 +++++++++++++++++++
 ...bmit_download_test.go => download_test.go} | 12 ++---
 internal/server/environment_vars.go           |  2 +
 internal/server/server.go                     |  4 +-
 internal/server/server_test.go                |  2 +-
 internal/server/submit_download.go            | 49 ------------------
 internal/util/util/translate.go               |  4 +-
 main.go                                       |  2 +-
 web/template/downloads.gotmpl                 |  4 +-
 15 files changed, 96 insertions(+), 91 deletions(-)
 rename internal/api/{submit_download.go => download.go} (86%)
 rename internal/api/{submit_download_test.go => download_test.go} (69%)
 create mode 100644 internal/server/download.go
 rename internal/server/{submit_download_test.go => download_test.go} (82%)
 delete mode 100644 internal/server/submit_download.go

diff --git a/adrs/0002-new-finance-back-end.md b/adrs/0002-new-finance-back-end.md
index 33f3601..a342c55 100644
--- a/adrs/0002-new-finance-back-end.md
+++ b/adrs/0002-new-finance-back-end.md
@@ -15,7 +15,7 @@ the source of truth for payments moving to us from SOP. We are therefore replaci
 ## Decision
 
 This will be a new Front End service following our established Golang FE pattern. The web pages it serves will have two 
-separate functions: Uploading files for processing, and downloading reports. Reportsing will be broken out into a separate
+separate functions: Uploading files for processing, and downloading reports. Reporting will be broken out into a separate
 microservice, as it has a defined scope and will allow us to provide resources for potentially long-running database queries
 without impacting other services. The architecture for processing files will depend on the file and how coupled the data
 are with existing processes.
diff --git a/internal/api/api_client.go b/internal/api/api_client.go
index 6f89f9e..194bb5d 100644
--- a/internal/api/api_client.go
+++ b/internal/api/api_client.go
@@ -22,10 +22,11 @@ func (e ClientError) Error() string {
 	return string(e)
 }
 
-func NewApiClient(httpClient HTTPClient, siriusUrl string) (*ApiClient, error) {
+func NewApiClient(httpClient HTTPClient, siriusUrl string, backendUrl string) (*ApiClient, error) {
 	return &ApiClient{
-		http:      httpClient,
-		siriusUrl: siriusUrl,
+		http:       httpClient,
+		siriusUrl:  siriusUrl,
+		backendUrl: backendUrl,
 	}, nil
 }
 
@@ -34,8 +35,9 @@ type HTTPClient interface {
 }
 
 type ApiClient struct {
-	http      HTTPClient
-	siriusUrl string
+	http       HTTPClient
+	siriusUrl  string
+	backendUrl string
 }
 
 type StatusError struct {
@@ -52,8 +54,8 @@ func (e StatusError) Data() interface{} {
 	return e
 }
 
-func (c *ApiClient) newSiriusRequest(ctx Context, method, path string, body io.Reader) (*http.Request, error) {
-	req, err := http.NewRequestWithContext(ctx.Context, method, c.siriusUrl+"/supervision-api/v1"+path, body)
+func (c *ApiClient) newBackendRequest(ctx Context, method, path string, body io.Reader) (*http.Request, error) {
+	req, err := http.NewRequestWithContext(ctx.Context, method, c.backendUrl+path, body)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/api/submit_download.go b/internal/api/download.go
similarity index 86%
rename from internal/api/submit_download.go
rename to internal/api/download.go
index c2987d6..7ad6b52 100644
--- a/internal/api/submit_download.go
+++ b/internal/api/download.go
@@ -7,7 +7,7 @@ import (
 	"net/http"
 )
 
-func (c *ApiClient) SubmitDownload(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateField string, dateFromField string, dateToField string, emailField string) error {
+func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateField string, dateFromField string, dateToField string, emailField string) error {
 	var body bytes.Buffer
 	var dateTransformed *model.Date
 	var toDateTransformed *model.Date
@@ -43,7 +43,7 @@ func (c *ApiClient) SubmitDownload(ctx Context, reportType string, reportJournal
 		return err
 	}
 
-	req, err := c.newSiriusRequest(ctx, http.MethodPost, "/downloads", &body)
+	req, err := c.newBackendRequest(ctx, http.MethodGet, "/downloads", &body)
 
 	if err != nil {
 		return err
diff --git a/internal/api/submit_download_test.go b/internal/api/download_test.go
similarity index 69%
rename from internal/api/submit_download_test.go
rename to internal/api/download_test.go
index 922964f..3ba78e5 100644
--- a/internal/api/submit_download_test.go
+++ b/internal/api/download_test.go
@@ -14,7 +14,7 @@ import (
 
 func TestSubmitDownload(t *testing.T) {
 	mockClient := SetUpTest()
-	client, _ := NewApiClient(mockClient, "http://localhost:3000")
+	client, _ := NewApiClient(mockClient, "http://localhost:3000", "")
 
 	data := `{
 		"reportType":         "AccountsReceivable",
@@ -38,7 +38,7 @@ func TestSubmitDownload(t *testing.T) {
 		}, nil
 	}
 
-	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
 	assert.Equal(t, nil, err)
 }
 
@@ -48,9 +48,9 @@ func TestSubmitDownloadUnauthorised(t *testing.T) {
 	}))
 	defer svr.Close()
 
-	client, _ := NewApiClient(http.DefaultClient, svr.URL)
+	client, _ := NewApiClient(http.DefaultClient, svr.URL, svr.URL)
 
-	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
 
 	assert.Equal(t, ErrUnauthorized.Error(), err.Error())
 }
@@ -61,20 +61,20 @@ func TestSubmitDownloadReturns500Error(t *testing.T) {
 	}))
 	defer svr.Close()
 
-	client, _ := NewApiClient(http.DefaultClient, svr.URL)
+	client, _ := NewApiClient(http.DefaultClient, svr.URL, svr.URL)
 
-	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
 
 	assert.Equal(t, StatusError{
 		Code:   http.StatusInternalServerError,
-		URL:    svr.URL + "/supervision-api/v1/downloads",
-		Method: http.MethodPost,
+		URL:    svr.URL + "/downloads",
+		Method: http.MethodGet,
 	}, err)
 }
 
 func TestSubmitDownloadReturnsBadRequestError(t *testing.T) {
 	mockClient := SetUpTest()
-	client, _ := NewApiClient(mockClient, "http://localhost:3000")
+	client, _ := NewApiClient(mockClient, "http://localhost:3000", "")
 
 	json := `
 		{"reasons":["StartDate","EndDate"]}
@@ -89,7 +89,7 @@ func TestSubmitDownloadReturnsBadRequestError(t *testing.T) {
 		}, nil
 	}
 
-	err := client.SubmitDownload(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
 
 	expectedError := model.ValidationError{Message: "", Errors: model.ValidationErrors{"EndDate": map[string]string{"EndDate": "EndDate"}, "StartDate": map[string]string{"StartDate": "StartDate"}}}
 	assert.Equal(t, expectedError, err)
@@ -111,9 +111,9 @@ func TestSubmitDownloadReturnsValidationError(t *testing.T) {
 	}))
 	defer svr.Close()
 
-	client, _ := NewApiClient(http.DefaultClient, svr.URL)
+	client, _ := NewApiClient(http.DefaultClient, svr.URL, svr.URL)
 
-	err := client.SubmitDownload(getContext(nil), "", "", "", "", "", "", "", "", "")
+	err := client.Download(getContext(nil), "", "", "", "", "", "", "", "", "")
 	expectedError := model.ValidationError{Message: "", Errors: model.ValidationErrors{"ReportType": map[string]string{"required": "Please select a report type"}}}
 	assert.Equal(t, expectedError, err.(model.ValidationError))
 }
diff --git a/internal/model/journal_type.go b/internal/model/journal_type.go
index dca9d03..eb8618e 100644
--- a/internal/model/journal_type.go
+++ b/internal/model/journal_type.go
@@ -3,7 +3,6 @@ package model
 var ReportJournalTypes = []ReportJournalType{
 	ReportTypeReceiptTransactions,
 	ReportTypeNonReceiptTransactions,
-	ReportTypeMOTOCardPayments,
 }
 
 type ReportJournalType int
@@ -12,7 +11,6 @@ const (
 	ReportTypeUnknown ReportJournalType = iota
 	ReportTypeReceiptTransactions
 	ReportTypeNonReceiptTransactions
-	ReportTypeMOTOCardPayments
 )
 
 func (i ReportJournalType) String() string {
@@ -25,8 +23,6 @@ func (i ReportJournalType) Translation() string {
 		return "Receipt Transactions"
 	case ReportTypeNonReceiptTransactions:
 		return "Non Receipt Transactions"
-	case ReportTypeMOTOCardPayments:
-		return "Accounts Receivable"
 	default:
 		return ""
 	}
@@ -38,8 +34,6 @@ func (i ReportJournalType) Key() string {
 		return "ReceiptTransactions"
 	case ReportTypeNonReceiptTransactions:
 		return "NonReceiptTransactions"
-	case ReportTypeMOTOCardPayments:
-		return "AccountsReceivable"
 	default:
 		return ""
 	}
diff --git a/internal/model/schedule_type.go b/internal/model/schedule_type.go
index d8b7701..3753424 100644
--- a/internal/model/schedule_type.go
+++ b/internal/model/schedule_type.go
@@ -1,6 +1,7 @@
 package model
 
 var ReportScheduleTypes = []ReportScheduleType{
+	ReportTypeMOTOCardPayments,
 	ReportTypeOnlineCardPayments,
 	ReportOPGBACSTransfer,
 	ReportSupervisionBACSTransfer,
@@ -33,6 +34,7 @@ type ReportScheduleType int
 
 const (
 	ReportScheduleTypeUnknown ReportScheduleType = iota
+	ReportTypeMOTOCardPayments
 	ReportTypeOnlineCardPayments
 	ReportOPGBACSTransfer
 	ReportSupervisionBACSTransfer
@@ -67,6 +69,8 @@ func (i ReportScheduleType) String() string {
 
 func (i ReportScheduleType) Translation() string {
 	switch i {
+	case ReportTypeMOTOCardPayments:
+		return "Accounts Receivable"
 	case ReportTypeOnlineCardPayments:
 		return "Online Card Payments"
 	case ReportOPGBACSTransfer:
@@ -126,6 +130,8 @@ func (i ReportScheduleType) Translation() string {
 
 func (i ReportScheduleType) Key() string {
 	switch i {
+	case ReportTypeMOTOCardPayments:
+		return "Accounts Receivable"
 	case ReportTypeOnlineCardPayments:
 		return "OnlineCardPayments"
 	case ReportOPGBACSTransfer:
diff --git a/internal/server/download.go b/internal/server/download.go
new file mode 100644
index 0000000..5e4c514
--- /dev/null
+++ b/internal/server/download.go
@@ -0,0 +1,50 @@
+package server
+
+import (
+	"errors"
+	"github.com/opg-sirius-finance-admin/internal/api"
+	"github.com/opg-sirius-finance-admin/internal/model"
+	"github.com/opg-sirius-finance-admin/internal/util/util"
+	"net/http"
+)
+
+type DownloadHandler struct {
+	router
+}
+
+func (h *DownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Request) error {
+	ctx := getContext(r)
+	params := r.URL.Query()
+
+	var (
+		reportType         = params.Get("reportType")
+		reportJournalType  = params.Get("reportJournalType")
+		reportScheduleType = params.Get("reportScheduleType")
+		reportAccountType  = params.Get("reportAccountType")
+		reportDebtType     = params.Get("reportDebtType")
+		dateField          = params.Get("dateField")
+		dateFromField      = params.Get("dateFromField")
+		dateToField        = params.Get("dateToField")
+		emailField         = params.Get("emailField")
+	)
+
+	err := h.Client().Download(ctx, reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateField, dateFromField, dateToField, emailField)
+
+	if err != nil {
+		var (
+			valErr model.ValidationError
+			stErr  api.StatusError
+		)
+		if errors.As(err, &valErr) {
+			data := AppVars{Errors: util.RenameErrors(valErr.Errors)}
+			w.WriteHeader(http.StatusUnprocessableEntity)
+			err = h.execute(w, r, data)
+		} else if errors.As(err, &stErr) {
+			data := AppVars{Error: stErr.Error()}
+			w.WriteHeader(stErr.Code)
+			err = h.execute(w, r, data)
+		}
+	}
+
+	return err
+}
diff --git a/internal/server/submit_download_test.go b/internal/server/download_test.go
similarity index 82%
rename from internal/server/submit_download_test.go
rename to internal/server/download_test.go
index 0154d91..b285b4d 100644
--- a/internal/server/submit_download_test.go
+++ b/internal/server/download_test.go
@@ -10,7 +10,7 @@ import (
 	"testing"
 )
 
-func TestSubmitManualInvoiceSuccess(t *testing.T) {
+func TestDownloadSuccess(t *testing.T) {
 	form := url.Values{
 		"reportType":         {"AccountsReceivable"},
 		"reportJournalType":  {""},
@@ -27,7 +27,7 @@ func TestSubmitManualInvoiceSuccess(t *testing.T) {
 	ro := &mockRoute{client: client}
 
 	w := httptest.NewRecorder()
-	r, _ := http.NewRequest(http.MethodPost, "/download", strings.NewReader(form.Encode()))
+	r, _ := http.NewRequest(http.MethodGet, "/download", strings.NewReader(form.Encode()))
 	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 	r.SetPathValue("clientId", "1")
 
@@ -37,14 +37,14 @@ func TestSubmitManualInvoiceSuccess(t *testing.T) {
 
 	appVars.EnvironmentVars.Prefix = "prefix"
 
-	sut := SubmitDownloadHandler{ro}
+	sut := DownloadHandler{ro}
 
 	err := sut.render(appVars, w, r)
 
 	assert.Nil(t, err)
 }
 
-func TestSubmitDownloadValidationErrors(t *testing.T) {
+func TestDownloadValidationErrors(t *testing.T) {
 	assert := assert.New(t)
 	client := &mockApiClient{}
 	ro := &mockRoute{client: client}
@@ -60,7 +60,7 @@ func TestSubmitDownloadValidationErrors(t *testing.T) {
 	}
 
 	w := httptest.NewRecorder()
-	r, _ := http.NewRequest(http.MethodPost, "/invoices", nil)
+	r, _ := http.NewRequest(http.MethodGet, "/download", nil)
 	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 	r.SetPathValue("clientId", "1")
 
@@ -68,7 +68,7 @@ func TestSubmitDownloadValidationErrors(t *testing.T) {
 		Path: "/add",
 	}
 
-	sut := SubmitDownloadHandler{ro}
+	sut := DownloadHandler{ro}
 	err := sut.render(appVars, w, r)
 	assert.Nil(err)
 	assert.Equal("422 Unprocessable Entity", w.Result().Status)
diff --git a/internal/server/environment_vars.go b/internal/server/environment_vars.go
index dea975a..6f4f16f 100644
--- a/internal/server/environment_vars.go
+++ b/internal/server/environment_vars.go
@@ -9,6 +9,7 @@ type EnvironmentVars struct {
 	WebDir          string
 	SiriusURL       string
 	SiriusPublicURL string
+	BackendUrl      string
 	Prefix          string
 }
 
@@ -19,6 +20,7 @@ func NewEnvironmentVars() EnvironmentVars {
 		SiriusURL:       getEnv("SIRIUS_URL", "http://host.docker.internal:8080"),
 		SiriusPublicURL: getEnv("SIRIUS_PUBLIC_URL", ""),
 		Prefix:          getEnv("PREFIX", ""),
+		BackendUrl:      getEnv("BACKEND_URL", ""),
 	}
 }
 
diff --git a/internal/server/server.go b/internal/server/server.go
index d623966..c58a597 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -14,7 +14,7 @@ import (
 )
 
 type ApiClient interface {
-	SubmitDownload(api.Context, string, string, string, string, string, string, string, string, string) error
+	Download(api.Context, string, string, string, string, string, string, string, string, string) error
 }
 
 type router interface {
@@ -40,7 +40,7 @@ func New(logger *slog.Logger, client ApiClient, templates map[string]*template.T
 	handleMux("GET /uploads", &GetUploadsHandler{&route{client: client, tmpl: templates["uploads.gotmpl"], partial: "uploads"}})
 	handleMux("GET /annual-invoicing-letters", &GetAnnualInvoicingLettersHandler{&route{client: client, tmpl: templates["annual_invoicing_letters.gotmpl"], partial: "annual-invoicing-letters"}})
 
-	handleMux("POST /downloads", &SubmitDownloadHandler{&route{client: client, tmpl: templates["downloads.gotmpl"], partial: "error-summary"}})
+	handleMux("GET /download", &DownloadHandler{&route{client: client, tmpl: templates["downloads.gotmpl"], partial: "error-summary"}})
 
 	mux.Handle("/health-check", healthCheck())
 
diff --git a/internal/server/server_test.go b/internal/server/server_test.go
index adfcd01..2d3f45c 100644
--- a/internal/server/server_test.go
+++ b/internal/server/server_test.go
@@ -51,6 +51,6 @@ type mockApiClient struct {
 	error error //nolint:golint,unused
 }
 
-func (m mockApiClient) SubmitDownload(context api.Context, s string, s2 string, s3 string, s4 string, s5 string, s6 string, s7 string, s8 string, s9 string) error {
+func (m mockApiClient) Download(context api.Context, s string, s2 string, s3 string, s4 string, s5 string, s6 string, s7 string, s8 string, s9 string) error {
 	return m.error
 }
diff --git a/internal/server/submit_download.go b/internal/server/submit_download.go
deleted file mode 100644
index 65a2e5e..0000000
--- a/internal/server/submit_download.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package server
-
-import (
-	"errors"
-	"github.com/opg-sirius-finance-admin/internal/api"
-	"github.com/opg-sirius-finance-admin/internal/model"
-	"github.com/opg-sirius-finance-admin/internal/util/util"
-	"net/http"
-)
-
-type SubmitDownloadHandler struct {
-	router
-}
-
-func (h *SubmitDownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Request) error {
-	ctx := getContext(r)
-
-	var (
-		reportType         = r.PostFormValue("reportType")
-		reportJournalType  = r.PostFormValue("reportJournalType")
-		reportScheduleType = r.PostFormValue("reportScheduleType")
-		reportAccountType  = r.PostFormValue("reportAccountType")
-		reportDebtType     = r.PostFormValue("reportDebtType")
-		dateField          = r.PostFormValue("dateField")
-		dateFromField      = r.PostFormValue("dateFromField")
-		dateToField        = r.PostFormValue("dateToField")
-		emailField         = r.PostFormValue("emailField")
-	)
-
-	err := h.Client().SubmitDownload(ctx, reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateField, dateFromField, dateToField, emailField)
-
-	if err != nil {
-		var (
-			valErr model.ValidationError
-			stErr  api.StatusError
-		)
-		if errors.As(err, &valErr) {
-			data := AppVars{Errors: util.RenameErrors(valErr.Errors)}
-			w.WriteHeader(http.StatusUnprocessableEntity)
-			err = h.execute(w, r, data)
-		} else if errors.As(err, &stErr) {
-			data := AppVars{Error: stErr.Error()}
-			w.WriteHeader(stErr.Code)
-			err = h.execute(w, r, data)
-		}
-	}
-
-	return err
-}
diff --git a/internal/util/util/translate.go b/internal/util/util/translate.go
index 3d56b9a..fb35e9f 100644
--- a/internal/util/util/translate.go
+++ b/internal/util/util/translate.go
@@ -19,10 +19,10 @@ var validationMappings = map[string]map[string]pair{
 		"date-in-the-past": pair{"Date", "The report date must be today or in the past"},
 	},
 	"FromDate": {
-		"FromDate": pair{"FromDate", "From date must be before to date"},
+		"FromDate": pair{"FromDate", "Date From must be before Date To"},
 	},
 	"ToDate": {
-		"ToDate": pair{"ToDate", "To date must be after from date"},
+		"ToDate": pair{"ToDate", "Date To must be after Date From"},
 	},
 }
 
diff --git a/main.go b/main.go
index fc8c479..c15d784 100644
--- a/main.go
+++ b/main.go
@@ -39,7 +39,7 @@ func run(ctx context.Context, logger *slog.Logger) error {
 	}
 
 	envVars := server.NewEnvironmentVars()
-	client, err := api.NewApiClient(http.DefaultClient, envVars.SiriusURL)
+	client, err := api.NewApiClient(http.DefaultClient, envVars.SiriusURL, envVars.BackendUrl)
 	if err != nil {
 		return err
 	}
diff --git a/web/template/downloads.gotmpl b/web/template/downloads.gotmpl
index 5ba3d99..17005bb 100644
--- a/web/template/downloads.gotmpl
+++ b/web/template/downloads.gotmpl
@@ -11,8 +11,8 @@
                 <div class="govuk-grid-row">
                     <form
                             class="govuk-grid-column-one-third"
-                            method="post"
-                            hx-post="{{ prefix "/downloads" }}"
+                            method="get"
+                            hx-get="{{ prefix "/download" }}"
                             hx-target="#error-summary"
                     >
                         <div class="govuk-form-group">

From 87a68035d181afd9128bbaa00aee6406a153df8f Mon Sep 17 00:00:00 2001
From: nicholassully <nicholas.sully@digital.justice.gov.uk>
Date: Tue, 13 Aug 2024 13:36:29 +0100
Subject: [PATCH 3/7] pfs-116 renaming fields

---
 internal/api/download.go         | 16 ++++++++--------
 internal/api/download_test.go    |  8 ++++----
 internal/model/download.go       |  2 +-
 internal/server/download.go      | 10 +++++-----
 internal/server/download_test.go |  8 ++++----
 web/template/downloads.gotmpl    |  8 ++++----
 6 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/internal/api/download.go b/internal/api/download.go
index 7ad6b52..6731413 100644
--- a/internal/api/download.go
+++ b/internal/api/download.go
@@ -7,24 +7,24 @@ import (
 	"net/http"
 )
 
-func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateField string, dateFromField string, dateToField string, emailField string) error {
+func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateOfTransaction string, dateFrom string, dateTo string, email string) error {
 	var body bytes.Buffer
 	var dateTransformed *model.Date
 	var toDateTransformed *model.Date
 	var fromDateTransformed *model.Date
 
-	if dateField != "" {
-		raisedDateFormatted := model.NewDate(dateField)
+	if dateOfTransaction != "" {
+		raisedDateFormatted := model.NewDate(dateOfTransaction)
 		dateTransformed = &raisedDateFormatted
 	}
 
-	if dateToField != "" {
-		startDateFormatted := model.NewDate(dateToField)
+	if dateTo != "" {
+		startDateFormatted := model.NewDate(dateTo)
 		toDateTransformed = &startDateFormatted
 	}
 
-	if dateFromField != "" {
-		endDateFormatted := model.NewDate(dateFromField)
+	if dateFrom != "" {
+		endDateFormatted := model.NewDate(dateFrom)
 		fromDateTransformed = &endDateFormatted
 	}
 
@@ -37,7 +37,7 @@ func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType s
 		DateField:          dateTransformed,
 		ToDateField:        toDateTransformed,
 		FromDateField:      fromDateTransformed,
-		Email:              emailField,
+		Email:              email,
 	})
 	if err != nil {
 		return err
diff --git a/internal/api/download_test.go b/internal/api/download_test.go
index 3ba78e5..9436ae0 100644
--- a/internal/api/download_test.go
+++ b/internal/api/download_test.go
@@ -22,10 +22,10 @@ func TestSubmitDownload(t *testing.T) {
 		"reportScheduleType": "",
 		"reportAccountType":  "BadDebtWriteOffReport",
 		"reportDebtType":     "",
-		"dateField":          "11/05/2024",
-		"dateFromField":      "01/04/2024",
-		"dateToField":        "31/03/2025",
-		"emailField":         "SomeSortOfEmail@example.com",
+		"dateOfTransaction":          "11/05/2024",
+		"dateFrom":      "01/04/2024",
+		"dateTo":        "31/03/2025",
+		"email":         "SomeSortOfEmail@example.com",
 	}
 	`
 
diff --git a/internal/model/download.go b/internal/model/download.go
index 2aad705..727e0e0 100644
--- a/internal/model/download.go
+++ b/internal/model/download.go
@@ -6,7 +6,7 @@ type Download struct {
 	ReportScheduleType string `json:"reportScheduleType"`
 	ReportAccountType  string `json:"reportAccountType"`
 	ReportDebtType     string `json:"reportDebtType"`
-	DateField          *Date  `json:"dateField,omitempty"`
+	DateField          *Date  `json:"dateOfTransaction,omitempty"`
 	ToDateField        *Date  `json:"toDateField,omitempty"`
 	FromDateField      *Date  `json:"fromDateField,omitempty"`
 	Email              string `json:"email"`
diff --git a/internal/server/download.go b/internal/server/download.go
index 5e4c514..b82bfc7 100644
--- a/internal/server/download.go
+++ b/internal/server/download.go
@@ -22,13 +22,13 @@ func (h *DownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Reque
 		reportScheduleType = params.Get("reportScheduleType")
 		reportAccountType  = params.Get("reportAccountType")
 		reportDebtType     = params.Get("reportDebtType")
-		dateField          = params.Get("dateField")
-		dateFromField      = params.Get("dateFromField")
-		dateToField        = params.Get("dateToField")
-		emailField         = params.Get("emailField")
+		dateOfTransaction  = params.Get("dateOfTransaction")
+		dateFrom           = params.Get("dateFrom")
+		dateTo             = params.Get("dateTo")
+		email              = params.Get("email")
 	)
 
-	err := h.Client().Download(ctx, reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateField, dateFromField, dateToField, emailField)
+	err := h.Client().Download(ctx, reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateOfTransaction, dateFrom, dateTo, email)
 
 	if err != nil {
 		var (
diff --git a/internal/server/download_test.go b/internal/server/download_test.go
index b285b4d..f741fdf 100644
--- a/internal/server/download_test.go
+++ b/internal/server/download_test.go
@@ -17,10 +17,10 @@ func TestDownloadSuccess(t *testing.T) {
 		"reportScheduleType": {""},
 		"reportAccountType":  {"BadDebtWriteOffReport"},
 		"reportDebtType":     {""},
-		"dateField":          {"11/05/2024"},
-		"dateFromField":      {"01/04/2024"},
-		"dateToField":        {"31/03/2025"},
-		"emailField":         {"SomeSortOfEmail@example.com"},
+		"dateOfTransaction":  {"11/05/2024"},
+		"dateFrom":           {"01/04/2024"},
+		"dateTo":             {"31/03/2025"},
+		"email":              {"SomeSortOfEmail@example.com"},
 	}
 
 	client := mockApiClient{}
diff --git a/web/template/downloads.gotmpl b/web/template/downloads.gotmpl
index 17005bb..c996de7 100644
--- a/web/template/downloads.gotmpl
+++ b/web/template/downloads.gotmpl
@@ -96,7 +96,7 @@
                                         Date
                                         <span id="error-message__Date"></span>
                                     </label>
-                                    <input disabled class="govuk-input govuk-input--width-10" id="date-field" name="dateField" type="date">
+                                    <input disabled class="govuk-input govuk-input--width-10" id="date-field" name="dateOfTransaction" type="date">
                                 </div>
                             </div>
 
@@ -106,7 +106,7 @@
                                         Date from
                                         <span id="error-message__FromDate"></span>
                                     </label>
-                                    <input disabled class="govuk-input govuk-input--width-10" id="date-from-field" name="dateFromField" type="date">
+                                    <input disabled class="govuk-input govuk-input--width-10" id="date-from-field" name="dateFrom" type="date">
                                 </div>
                             </div>
 
@@ -116,7 +116,7 @@
                                         Date to
                                         <span id="error-message__ToDate"></span>
                                     </label>
-                                    <input disabled class="govuk-input govuk-input--width-10" id="date-to-field" name="dateToField" type="date">
+                                    <input disabled class="govuk-input govuk-input--width-10" id="date-to-field" name="dateTo" type="date">
                                 </div>
                             </div>
 
@@ -129,7 +129,7 @@
                                     <div id="email-hint" class="govuk-hint">
                                         We’ll only use this to send you the finished report
                                     </div>
-                                    <input disabled class="govuk-input" id="email-field" name="emailField" type="email" spellcheck="false" aria-describedby="email-hint" autocomplete="email">
+                                    <input disabled class="govuk-input" id="email-field" name="email" type="email" spellcheck="false" aria-describedby="email-hint" autocomplete="email">
                                 </div>
                             </div>
 

From cfdf923c7c948383617591a32e5de788663a27cc Mon Sep 17 00:00:00 2001
From: nicholassully <nicholas.sully@digital.justice.gov.uk>
Date: Tue, 27 Aug 2024 13:53:16 +0100
Subject: [PATCH 4/7] pfs-116 pre feedback

---
 internal/api/api_client.go                    |   8 +-
 internal/api/api_client_test.go               |   5 -
 internal/api/download.go                      |  59 +++++-----
 internal/api/download_test.go                 | 106 +++++++++++++-----
 internal/model/date_test.go                   |   8 +-
 internal/model/download.go                    |   2 +-
 internal/server/app_vars.go                   |  12 +-
 internal/server/download.go                   |   9 +-
 internal/server/download_test.go              |  33 +++++-
 internal/server/get_downloads.go              |  20 ++--
 internal/server/server.go                     |   2 +-
 internal/server/server_test.go                |   2 +-
 internal/{util/util => server}/translate.go   |   2 +-
 .../{util/util => server}/translate_test.go   |   2 +-
 main.go                                       |   2 +-
 15 files changed, 171 insertions(+), 101 deletions(-)
 rename internal/{util/util => server}/translate.go (98%)
 rename internal/{util/util => server}/translate_test.go (98%)

diff --git a/internal/api/api_client.go b/internal/api/api_client.go
index 194bb5d..3249b64 100644
--- a/internal/api/api_client.go
+++ b/internal/api/api_client.go
@@ -22,8 +22,8 @@ func (e ClientError) Error() string {
 	return string(e)
 }
 
-func NewApiClient(httpClient HTTPClient, siriusUrl string, backendUrl string) (*ApiClient, error) {
-	return &ApiClient{
+func NewClient(httpClient HTTPClient, siriusUrl string, backendUrl string) (*Client, error) {
+	return &Client{
 		http:       httpClient,
 		siriusUrl:  siriusUrl,
 		backendUrl: backendUrl,
@@ -34,7 +34,7 @@ type HTTPClient interface {
 	Do(req *http.Request) (*http.Response, error)
 }
 
-type ApiClient struct {
+type Client struct {
 	http       HTTPClient
 	siriusUrl  string
 	backendUrl string
@@ -54,7 +54,7 @@ func (e StatusError) Data() interface{} {
 	return e
 }
 
-func (c *ApiClient) newBackendRequest(ctx Context, method, path string, body io.Reader) (*http.Request, error) {
+func (c *Client) newBackendRequest(ctx Context, method, path string, body io.Reader) (*http.Request, error) {
 	req, err := http.NewRequestWithContext(ctx.Context, method, c.backendUrl+path, body)
 	if err != nil {
 		return nil, err
diff --git a/internal/api/api_client_test.go b/internal/api/api_client_test.go
index 02620ec..e3bb375 100644
--- a/internal/api/api_client_test.go
+++ b/internal/api/api_client_test.go
@@ -46,8 +46,3 @@ func TestStatusError(t *testing.T) {
 	assert.Equal(t, "POST /some/url returned 418", err.Error())
 	assert.Equal(t, err, err.Data())
 }
-
-func SetUpTest() *MockClient {
-	mockClient := &MockClient{}
-	return mockClient
-}
diff --git a/internal/api/download.go b/internal/api/download.go
index 6731413..ad2e30f 100644
--- a/internal/api/download.go
+++ b/internal/api/download.go
@@ -7,26 +7,9 @@ import (
 	"net/http"
 )
 
-func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateOfTransaction string, dateFrom string, dateTo string, email string) error {
+func (c *Client) Download(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateOfTransaction string, dateFrom string, dateTo string, email string) error {
 	var body bytes.Buffer
-	var dateTransformed *model.Date
-	var toDateTransformed *model.Date
-	var fromDateTransformed *model.Date
-
-	if dateOfTransaction != "" {
-		raisedDateFormatted := model.NewDate(dateOfTransaction)
-		dateTransformed = &raisedDateFormatted
-	}
-
-	if dateTo != "" {
-		startDateFormatted := model.NewDate(dateTo)
-		toDateTransformed = &startDateFormatted
-	}
-
-	if dateFrom != "" {
-		endDateFormatted := model.NewDate(dateFrom)
-		fromDateTransformed = &endDateFormatted
-	}
+	dateTransformed, toDateTransformed, fromDateTransformed := NewDownload(dateOfTransaction, dateTo, dateFrom)
 
 	err := json.NewEncoder(&body).Encode(model.Download{
 		ReportType:         reportType,
@@ -34,7 +17,7 @@ func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType s
 		ReportScheduleType: reportScheduleType,
 		ReportAccountType:  reportAccountType,
 		ReportDebtType:     reportDebtType,
-		DateField:          dateTransformed,
+		DateOfTransaction:  dateTransformed,
 		ToDateField:        toDateTransformed,
 		FromDateField:      fromDateTransformed,
 		Email:              email,
@@ -56,28 +39,26 @@ func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType s
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode == http.StatusCreated {
+	switch resp.StatusCode {
+	case http.StatusCreated:
 		return nil
-	}
 
-	if resp.StatusCode == http.StatusUnauthorized {
+	case http.StatusUnauthorized:
 		return ErrUnauthorized
-	}
 
-	if resp.StatusCode == http.StatusUnprocessableEntity {
+	case http.StatusUnprocessableEntity:
 		var v model.ValidationError
 		if err := json.NewDecoder(resp.Body).Decode(&v); err == nil && len(v.Errors) > 0 {
 			return model.ValidationError{Errors: v.Errors}
 		}
-	}
 
-	if resp.StatusCode == http.StatusBadRequest {
+	case http.StatusBadRequest:
 		var badRequests model.BadRequests
 		if err := json.NewDecoder(resp.Body).Decode(&badRequests); err != nil {
 			return err
 		}
 
-		validationErrors := make(model.ValidationErrors)
+		validationErrors := model.ValidationErrors{}
 		for _, reason := range badRequests.Reasons {
 			innerMap := make(map[string]string)
 			innerMap[reason] = reason
@@ -89,3 +70,25 @@ func (c *ApiClient) Download(ctx Context, reportType string, reportJournalType s
 
 	return newStatusError(resp)
 }
+
+func NewDownload(dateOfTransaction string, dateTo string, dateFrom string) (*model.Date, *model.Date, *model.Date) {
+	var dateTransformed *model.Date
+	var toDateTransformed *model.Date
+	var fromDateTransformed *model.Date
+
+	if dateOfTransaction != "" {
+		raisedDateFormatted := model.NewDate(dateOfTransaction)
+		dateTransformed = &raisedDateFormatted
+	}
+
+	if dateTo != "" {
+		startDateFormatted := model.NewDate(dateTo)
+		toDateTransformed = &startDateFormatted
+	}
+
+	if dateFrom != "" {
+		endDateFormatted := model.NewDate(dateFrom)
+		fromDateTransformed = &endDateFormatted
+	}
+	return dateTransformed, toDateTransformed, fromDateTransformed
+}
diff --git a/internal/api/download_test.go b/internal/api/download_test.go
index 9436ae0..e47885d 100644
--- a/internal/api/download_test.go
+++ b/internal/api/download_test.go
@@ -8,13 +8,14 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
 
 func TestSubmitDownload(t *testing.T) {
-	mockClient := SetUpTest()
-	client, _ := NewApiClient(mockClient, "http://localhost:3000", "")
+	mockClient := &MockClient{}
+	client, _ := NewClient(mockClient, "http://localhost:3000", "")
 
 	data := `{
 		"reportType":         "AccountsReceivable",
@@ -22,10 +23,10 @@ func TestSubmitDownload(t *testing.T) {
 		"reportScheduleType": "",
 		"reportAccountType":  "BadDebtWriteOffReport",
 		"reportDebtType":     "",
-		"dateOfTransaction":          "11/05/2024",
-		"dateFrom":      "01/04/2024",
-		"dateTo":        "31/03/2025",
-		"email":         "SomeSortOfEmail@example.com",
+		"dateOfTransaction":  "11/05/2024",
+		"dateFrom":           "01/04/2024",
+		"dateTo":             "31/03/2025",
+		"email":              "SomeSortOfEmail@example.com",
 	}
 	`
 
@@ -43,38 +44,24 @@ func TestSubmitDownload(t *testing.T) {
 }
 
 func TestSubmitDownloadUnauthorised(t *testing.T) {
-	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusUnauthorized)
-	}))
-	defer svr.Close()
+	mockClient := &MockClient{}
+	client, _ := NewClient(mockClient, "http://localhost:3000", "")
 
-	client, _ := NewApiClient(http.DefaultClient, svr.URL, svr.URL)
+	GetDoFunc = func(*http.Request) (*http.Response, error) {
+		return &http.Response{
+			StatusCode: http.StatusUnauthorized,
+			Body:       io.NopCloser(bytes.NewReader([]byte{})), // Empty body
+		}, nil
+	}
 
 	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
 
 	assert.Equal(t, ErrUnauthorized.Error(), err.Error())
 }
 
-func TestSubmitDownloadReturns500Error(t *testing.T) {
-	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusInternalServerError)
-	}))
-	defer svr.Close()
-
-	client, _ := NewApiClient(http.DefaultClient, svr.URL, svr.URL)
-
-	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
-
-	assert.Equal(t, StatusError{
-		Code:   http.StatusInternalServerError,
-		URL:    svr.URL + "/downloads",
-		Method: http.MethodGet,
-	}, err)
-}
-
 func TestSubmitDownloadReturnsBadRequestError(t *testing.T) {
-	mockClient := SetUpTest()
-	client, _ := NewApiClient(mockClient, "http://localhost:3000", "")
+	mockClient := &MockClient{}
+	client, _ := NewClient(mockClient, "http://localhost:3000", "")
 
 	json := `
 		{"reasons":["StartDate","EndDate"]}
@@ -111,9 +98,66 @@ func TestSubmitDownloadReturnsValidationError(t *testing.T) {
 	}))
 	defer svr.Close()
 
-	client, _ := NewApiClient(http.DefaultClient, svr.URL, svr.URL)
+	client, _ := NewClient(http.DefaultClient, svr.URL, svr.URL)
 
 	err := client.Download(getContext(nil), "", "", "", "", "", "", "", "", "")
 	expectedError := model.ValidationError{Message: "", Errors: model.ValidationErrors{"ReportType": map[string]string{"required": "Please select a report type"}}}
 	assert.Equal(t, expectedError, err.(model.ValidationError))
 }
+
+func TestNewDownload(t *testing.T) {
+	type args struct {
+		dateOfTransaction string
+		dateTo            string
+		dateFrom          string
+	}
+	tests := []struct {
+		name  string
+		args  args
+		want  *model.Date
+		want1 *model.Date
+		want2 *model.Date
+	}{
+		{
+			name: "No dates passed in no dates are returned",
+			args: args{
+				dateOfTransaction: "",
+				dateTo:            "",
+				dateFrom:          "",
+			},
+			want:  nil,
+			want1: nil,
+			want2: nil,
+		},
+		{
+			name: "All dates passed in all dates are returned",
+			args: args{
+				dateOfTransaction: "01/01/2021",
+				dateTo:            "02/02/2022",
+				dateFrom:          "03/03/2023",
+			},
+			want:  &model.Date{Time: time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC)},
+			want1: &model.Date{Time: time.Date(2022, time.February, 2, 0, 0, 0, 0, time.UTC)},
+			want2: &model.Date{Time: time.Date(2023, time.March, 3, 0, 0, 0, 0, time.UTC)},
+		},
+		{
+			name: "Only one date passed in one date is returned",
+			args: args{
+				dateOfTransaction: "01/01/2021",
+				dateTo:            "",
+				dateFrom:          "",
+			},
+			want:  &model.Date{Time: time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC)},
+			want1: nil,
+			want2: nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1, got2 := NewDownload(tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
+			assert.Equalf(t, tt.want, got, "NewDownload(%v, %v, %v)", tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
+			assert.Equalf(t, tt.want1, got1, "NewDownload(%v, %v, %v)", tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
+			assert.Equalf(t, tt.want2, got2, "NewDownload(%v, %v, %v)", tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
+		})
+	}
+}
diff --git a/internal/model/date_test.go b/internal/model/date_test.go
index 7a8d5fd..f5b2546 100644
--- a/internal/model/date_test.go
+++ b/internal/model/date_test.go
@@ -78,24 +78,28 @@ func TestDate_Before_And_After(t *testing.T) {
 
 func TestDate_IsNull(t *testing.T) {
 	tests := []struct {
+		name string
 		date Date
 		want bool
 	}{
 		{
+			name: "Date passed in is not null",
 			date: NewDate("01/01/2020"),
 			want: false,
 		},
 		{
+			name: "Date passed matches a nil date",
 			date: NewDate("01/01/0001"),
 			want: true,
 		},
 		{
+			name: "Date passed is null",
 			date: Date{},
 			want: true,
 		},
 	}
-	for i, test := range tests {
-		t.Run("Scenario "+strconv.Itoa(i+1), func(t *testing.T) {
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
 			assert.Equal(t, test.want, test.date.IsNull())
 		})
 	}
diff --git a/internal/model/download.go b/internal/model/download.go
index 727e0e0..e75e4ec 100644
--- a/internal/model/download.go
+++ b/internal/model/download.go
@@ -6,7 +6,7 @@ type Download struct {
 	ReportScheduleType string `json:"reportScheduleType"`
 	ReportAccountType  string `json:"reportAccountType"`
 	ReportDebtType     string `json:"reportDebtType"`
-	DateField          *Date  `json:"dateOfTransaction,omitempty"`
+	DateOfTransaction  *Date  `json:"dateOfTransaction,omitempty"`
 	ToDateField        *Date  `json:"toDateField,omitempty"`
 	FromDateField      *Date  `json:"fromDateField,omitempty"`
 	Email              string `json:"email"`
diff --git a/internal/server/app_vars.go b/internal/server/app_vars.go
index e60c100..a69a096 100644
--- a/internal/server/app_vars.go
+++ b/internal/server/app_vars.go
@@ -7,12 +7,12 @@ import (
 )
 
 type AppVars struct {
-	Path            string
-	XSRFToken       string
-	Tabs            []Tab
-	EnvironmentVars EnvironmentVars
-	Errors          model.ValidationErrors
-	Error           string
+	Path             string
+	XSRFToken        string
+	Tabs             []Tab
+	EnvironmentVars  EnvironmentVars
+	ValidationErrors model.ValidationErrors
+	Error            string
 }
 
 type Tab struct {
diff --git a/internal/server/download.go b/internal/server/download.go
index b82bfc7..fd781b9 100644
--- a/internal/server/download.go
+++ b/internal/server/download.go
@@ -4,17 +4,16 @@ import (
 	"errors"
 	"github.com/opg-sirius-finance-admin/internal/api"
 	"github.com/opg-sirius-finance-admin/internal/model"
-	"github.com/opg-sirius-finance-admin/internal/util/util"
 	"net/http"
 )
 
-type DownloadHandler struct {
+type GetDownloadHandler struct {
 	router
 }
 
-func (h *DownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Request) error {
+func (h *GetDownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Request) error {
 	ctx := getContext(r)
-	params := r.URL.Query()
+	params := r.Form
 
 	var (
 		reportType         = params.Get("reportType")
@@ -36,7 +35,7 @@ func (h *DownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Reque
 			stErr  api.StatusError
 		)
 		if errors.As(err, &valErr) {
-			data := AppVars{Errors: util.RenameErrors(valErr.Errors)}
+			data := AppVars{ValidationErrors: RenameErrors(valErr.Errors)}
 			w.WriteHeader(http.StatusUnprocessableEntity)
 			err = h.execute(w, r, data)
 		} else if errors.As(err, &stErr) {
diff --git a/internal/server/download_test.go b/internal/server/download_test.go
index f741fdf..935dba6 100644
--- a/internal/server/download_test.go
+++ b/internal/server/download_test.go
@@ -1,6 +1,7 @@
 package server
 
 import (
+	"github.com/opg-sirius-finance-admin/internal/api"
 	"github.com/opg-sirius-finance-admin/internal/model"
 	"github.com/stretchr/testify/assert"
 	"net/http"
@@ -27,7 +28,7 @@ func TestDownloadSuccess(t *testing.T) {
 	ro := &mockRoute{client: client}
 
 	w := httptest.NewRecorder()
-	r, _ := http.NewRequest(http.MethodGet, "/download", strings.NewReader(form.Encode()))
+	r, _ := http.NewRequest(http.MethodPost, "/download", strings.NewReader(form.Encode()))
 	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 	r.SetPathValue("clientId", "1")
 
@@ -37,7 +38,7 @@ func TestDownloadSuccess(t *testing.T) {
 
 	appVars.EnvironmentVars.Prefix = "prefix"
 
-	sut := DownloadHandler{ro}
+	sut := GetDownloadHandler{ro}
 
 	err := sut.render(appVars, w, r)
 
@@ -62,14 +63,38 @@ func TestDownloadValidationErrors(t *testing.T) {
 	w := httptest.NewRecorder()
 	r, _ := http.NewRequest(http.MethodGet, "/download", nil)
 	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-	r.SetPathValue("clientId", "1")
 
 	appVars := AppVars{
 		Path: "/add",
 	}
 
-	sut := DownloadHandler{ro}
+	sut := GetDownloadHandler{ro}
 	err := sut.render(appVars, w, r)
 	assert.Nil(err)
 	assert.Equal("422 Unprocessable Entity", w.Result().Status)
 }
+
+func TestDownloadStatusError(t *testing.T) {
+	assert := assert.New(t)
+	client := &mockApiClient{}
+	ro := &mockRoute{client: client}
+
+	client.error = api.StatusError{
+		Code:   http.StatusInternalServerError,
+		URL:    "/downloads",
+		Method: http.MethodGet,
+	}
+
+	w := httptest.NewRecorder()
+	r, _ := http.NewRequest(http.MethodGet, "/download", nil)
+	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+
+	appVars := AppVars{
+		Path: "/add",
+	}
+
+	sut := GetDownloadHandler{ro}
+	err := sut.render(appVars, w, r)
+	assert.Nil(err)
+	assert.Equal(http.StatusInternalServerError, w.Result().StatusCode)
+}
diff --git a/internal/server/get_downloads.go b/internal/server/get_downloads.go
index 7a45af9..6945e01 100644
--- a/internal/server/get_downloads.go
+++ b/internal/server/get_downloads.go
@@ -6,11 +6,11 @@ import (
 )
 
 type GetDownloadsVars struct {
-	ReportsTypes        *[]model.ReportsType
-	ReportJournalTypes  *[]model.ReportJournalType
-	ReportScheduleTypes *[]model.ReportScheduleType
-	ReportAccountTypes  *[]model.ReportAccountType
-	ReportDebtTypes     *[]model.ReportDebtType
+	ReportsTypes        []model.ReportsType
+	ReportJournalTypes  []model.ReportJournalType
+	ReportScheduleTypes []model.ReportScheduleType
+	ReportAccountTypes  []model.ReportAccountType
+	ReportDebtTypes     []model.ReportDebtType
 	AppVars
 }
 
@@ -20,11 +20,11 @@ type GetDownloadsHandler struct {
 
 func (h *GetDownloadsHandler) render(v AppVars, w http.ResponseWriter, r *http.Request) error {
 	data := GetDownloadsVars{
-		&model.ReportsTypes,
-		&model.ReportJournalTypes,
-		&model.ReportScheduleTypes,
-		&model.ReportAccountTypes,
-		&model.ReportDebtTypes,
+		model.ReportsTypes,
+		model.ReportJournalTypes,
+		model.ReportScheduleTypes,
+		model.ReportAccountTypes,
+		model.ReportDebtTypes,
 		v}
 	data.selectTab("downloads")
 	return h.execute(w, r, data)
diff --git a/internal/server/server.go b/internal/server/server.go
index c58a597..6738293 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -40,7 +40,7 @@ func New(logger *slog.Logger, client ApiClient, templates map[string]*template.T
 	handleMux("GET /uploads", &GetUploadsHandler{&route{client: client, tmpl: templates["uploads.gotmpl"], partial: "uploads"}})
 	handleMux("GET /annual-invoicing-letters", &GetAnnualInvoicingLettersHandler{&route{client: client, tmpl: templates["annual_invoicing_letters.gotmpl"], partial: "annual-invoicing-letters"}})
 
-	handleMux("GET /download", &DownloadHandler{&route{client: client, tmpl: templates["downloads.gotmpl"], partial: "error-summary"}})
+	handleMux("GET /download", &GetDownloadHandler{&route{client: client, tmpl: templates["downloads.gotmpl"], partial: "error-summary"}})
 
 	mux.Handle("/health-check", healthCheck())
 
diff --git a/internal/server/server_test.go b/internal/server/server_test.go
index 2d3f45c..6ed88a4 100644
--- a/internal/server/server_test.go
+++ b/internal/server/server_test.go
@@ -51,6 +51,6 @@ type mockApiClient struct {
 	error error //nolint:golint,unused
 }
 
-func (m mockApiClient) Download(context api.Context, s string, s2 string, s3 string, s4 string, s5 string, s6 string, s7 string, s8 string, s9 string) error {
+func (m mockApiClient) Download(context api.Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateOfTransaction string, dateFrom string, dateTo string, email string) error {
 	return m.error
 }
diff --git a/internal/util/util/translate.go b/internal/server/translate.go
similarity index 98%
rename from internal/util/util/translate.go
rename to internal/server/translate.go
index fb35e9f..cbb2a56 100644
--- a/internal/util/util/translate.go
+++ b/internal/server/translate.go
@@ -1,4 +1,4 @@
-package util
+package server
 
 import "github.com/opg-sirius-finance-admin/internal/model"
 
diff --git a/internal/util/util/translate_test.go b/internal/server/translate_test.go
similarity index 98%
rename from internal/util/util/translate_test.go
rename to internal/server/translate_test.go
index f837072..350e70d 100644
--- a/internal/util/util/translate_test.go
+++ b/internal/server/translate_test.go
@@ -1,4 +1,4 @@
-package util
+package server
 
 import (
 	"github.com/opg-sirius-finance-admin/internal/model"
diff --git a/main.go b/main.go
index c15d784..b33c853 100644
--- a/main.go
+++ b/main.go
@@ -39,7 +39,7 @@ func run(ctx context.Context, logger *slog.Logger) error {
 	}
 
 	envVars := server.NewEnvironmentVars()
-	client, err := api.NewApiClient(http.DefaultClient, envVars.SiriusURL, envVars.BackendUrl)
+	client, err := api.NewClient(http.DefaultClient, envVars.SiriusURL, envVars.BackendUrl)
 	if err != nil {
 		return err
 	}

From b3e73624284e7a4e89b71f062d4b893de2065cd9 Mon Sep 17 00:00:00 2001
From: nicholassully <nicholas.sully@digital.justice.gov.uk>
Date: Wed, 28 Aug 2024 13:09:17 +0100
Subject: [PATCH 5/7] pfs-116 moved logic out of the api layer

---
 internal/api/api_client_test.go |   1 -
 internal/api/download.go        |  37 +--------
 internal/api/download_test.go   | 143 ++++++++++++++------------------
 internal/model/download.go      |  28 +++++++
 internal/model/download_test.go |  99 ++++++++++++++++++++++
 internal/server/download.go     |   3 +-
 internal/server/server.go       |   3 +-
 internal/server/server_test.go  |   3 +-
 8 files changed, 195 insertions(+), 122 deletions(-)
 create mode 100644 internal/model/download_test.go

diff --git a/internal/api/api_client_test.go b/internal/api/api_client_test.go
index e3bb375..65b1272 100644
--- a/internal/api/api_client_test.go
+++ b/internal/api/api_client_test.go
@@ -13,7 +13,6 @@ type MockClient struct {
 }
 
 var (
-	// GetDoFunc fetches the mock client's `Do` func. Implement this within a test to modify the client's behaviour.
 	GetDoFunc func(req *http.Request) (*http.Response, error)
 )
 
diff --git a/internal/api/download.go b/internal/api/download.go
index ad2e30f..f24cf56 100644
--- a/internal/api/download.go
+++ b/internal/api/download.go
@@ -7,21 +7,10 @@ import (
 	"net/http"
 )
 
-func (c *Client) Download(ctx Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateOfTransaction string, dateFrom string, dateTo string, email string) error {
+func (c *Client) Download(ctx Context, data model.Download) error {
 	var body bytes.Buffer
-	dateTransformed, toDateTransformed, fromDateTransformed := NewDownload(dateOfTransaction, dateTo, dateFrom)
 
-	err := json.NewEncoder(&body).Encode(model.Download{
-		ReportType:         reportType,
-		ReportJournalType:  reportJournalType,
-		ReportScheduleType: reportScheduleType,
-		ReportAccountType:  reportAccountType,
-		ReportDebtType:     reportDebtType,
-		DateOfTransaction:  dateTransformed,
-		ToDateField:        toDateTransformed,
-		FromDateField:      fromDateTransformed,
-		Email:              email,
-	})
+	err := json.NewEncoder(&body).Encode(data)
 	if err != nil {
 		return err
 	}
@@ -70,25 +59,3 @@ func (c *Client) Download(ctx Context, reportType string, reportJournalType stri
 
 	return newStatusError(resp)
 }
-
-func NewDownload(dateOfTransaction string, dateTo string, dateFrom string) (*model.Date, *model.Date, *model.Date) {
-	var dateTransformed *model.Date
-	var toDateTransformed *model.Date
-	var fromDateTransformed *model.Date
-
-	if dateOfTransaction != "" {
-		raisedDateFormatted := model.NewDate(dateOfTransaction)
-		dateTransformed = &raisedDateFormatted
-	}
-
-	if dateTo != "" {
-		startDateFormatted := model.NewDate(dateTo)
-		toDateTransformed = &startDateFormatted
-	}
-
-	if dateFrom != "" {
-		endDateFormatted := model.NewDate(dateFrom)
-		fromDateTransformed = &endDateFormatted
-	}
-	return dateTransformed, toDateTransformed, fromDateTransformed
-}
diff --git a/internal/api/download_test.go b/internal/api/download_test.go
index e47885d..6c028e3 100644
--- a/internal/api/download_test.go
+++ b/internal/api/download_test.go
@@ -16,45 +16,57 @@ import (
 func TestSubmitDownload(t *testing.T) {
 	mockClient := &MockClient{}
 	client, _ := NewClient(mockClient, "http://localhost:3000", "")
-
-	data := `{
-		"reportType":         "AccountsReceivable",
-		"reportJournalType":  "",
-		"reportScheduleType": "",
-		"reportAccountType":  "BadDebtWriteOffReport",
-		"reportDebtType":     "",
-		"dateOfTransaction":  "11/05/2024",
-		"dateFrom":           "01/04/2024",
-		"dateTo":             "31/03/2025",
-		"email":              "SomeSortOfEmail@example.com",
+	dateOfTransaction := model.Date{Time: time.Date(2024, 5, 11, 0, 0, 0, 0, time.UTC)}
+	dateTo := model.Date{Time: time.Date(2025, 6, 15, 0, 0, 0, 0, time.UTC)}
+	dateFrom := model.Date{Time: time.Date(2022, 7, 21, 0, 0, 0, 0, time.UTC)}
+
+	data := model.Download{
+		ReportType:         "reportType",
+		ReportJournalType:  "reportJournalType",
+		ReportScheduleType: "reportScheduleType",
+		ReportAccountType:  "reportAccountType",
+		ReportDebtType:     "reportDebtType",
+		DateOfTransaction:  &dateOfTransaction,
+		ToDateField:        &dateTo,
+		FromDateField:      &dateFrom,
+		Email:              "Something@example.com",
 	}
-	`
-
-	r := io.NopCloser(bytes.NewReader([]byte(data)))
 
 	GetDoFunc = func(*http.Request) (*http.Response, error) {
 		return &http.Response{
-			StatusCode: 201,
-			Body:       r,
+			StatusCode: http.StatusCreated,
+			Body:       io.NopCloser(bytes.NewReader([]byte{})),
 		}, nil
 	}
 
-	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
-	assert.Equal(t, nil, err)
+	err := client.Download(getContext(nil), data)
+	assert.NoError(t, err)
 }
 
 func TestSubmitDownloadUnauthorised(t *testing.T) {
 	mockClient := &MockClient{}
 	client, _ := NewClient(mockClient, "http://localhost:3000", "")
 
+	data := model.Download{
+		ReportType:         "reportType",
+		ReportJournalType:  "reportJournalType",
+		ReportScheduleType: "reportScheduleType",
+		ReportAccountType:  "reportAccountType",
+		ReportDebtType:     "reportDebtType",
+		DateOfTransaction:  nil,
+		ToDateField:        nil,
+		FromDateField:      nil,
+		Email:              "Something@example.com",
+	}
+
 	GetDoFunc = func(*http.Request) (*http.Response, error) {
 		return &http.Response{
 			StatusCode: http.StatusUnauthorized,
-			Body:       io.NopCloser(bytes.NewReader([]byte{})), // Empty body
+			Body:       io.NopCloser(bytes.NewReader([]byte{})),
 		}, nil
 	}
 
-	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+	err := client.Download(getContext(nil), data)
 
 	assert.Equal(t, ErrUnauthorized.Error(), err.Error())
 }
@@ -63,26 +75,48 @@ func TestSubmitDownloadReturnsBadRequestError(t *testing.T) {
 	mockClient := &MockClient{}
 	client, _ := NewClient(mockClient, "http://localhost:3000", "")
 
-	json := `
-		{"reasons":["StartDate","EndDate"]}
-	`
+	data := model.Download{
+		ReportType:         "reportType",
+		ReportJournalType:  "reportJournalType",
+		ReportScheduleType: "reportScheduleType",
+		ReportAccountType:  "reportAccountType",
+		ReportDebtType:     "reportDebtType",
+		DateOfTransaction:  nil,
+		ToDateField:        nil,
+		FromDateField:      nil,
+		Email:              "Something@example.com",
+	}
+
+	json := `{"reasons":["StartDate","EndDate"]}`
 
 	r := io.NopCloser(bytes.NewReader([]byte(json)))
 
 	GetDoFunc = func(*http.Request) (*http.Response, error) {
 		return &http.Response{
-			StatusCode: 400,
+			StatusCode: http.StatusBadRequest,
 			Body:       r,
 		}, nil
 	}
 
-	err := client.Download(getContext(nil), "AccountsReceivable", "", "", "BadDebtWriteOffReport", "", "11/05/2024", "01/04/2024", "31/03/2025", "SomeSortOfEmail@example.com")
+	err := client.Download(getContext(nil), data)
 
 	expectedError := model.ValidationError{Message: "", Errors: model.ValidationErrors{"EndDate": map[string]string{"EndDate": "EndDate"}, "StartDate": map[string]string{"StartDate": "StartDate"}}}
 	assert.Equal(t, expectedError, err)
 }
 
 func TestSubmitDownloadReturnsValidationError(t *testing.T) {
+	data := model.Download{
+		ReportType:         "",
+		ReportJournalType:  "reportJournalType",
+		ReportScheduleType: "reportScheduleType",
+		ReportAccountType:  "reportAccountType",
+		ReportDebtType:     "reportDebtType",
+		DateOfTransaction:  nil,
+		ToDateField:        nil,
+		FromDateField:      nil,
+		Email:              "Something@example.com",
+	}
+
 	validationErrors := model.ValidationError{
 		Message: "Validation failed",
 		Errors: map[string]map[string]string{
@@ -100,64 +134,7 @@ func TestSubmitDownloadReturnsValidationError(t *testing.T) {
 
 	client, _ := NewClient(http.DefaultClient, svr.URL, svr.URL)
 
-	err := client.Download(getContext(nil), "", "", "", "", "", "", "", "", "")
+	err := client.Download(getContext(nil), data)
 	expectedError := model.ValidationError{Message: "", Errors: model.ValidationErrors{"ReportType": map[string]string{"required": "Please select a report type"}}}
 	assert.Equal(t, expectedError, err.(model.ValidationError))
 }
-
-func TestNewDownload(t *testing.T) {
-	type args struct {
-		dateOfTransaction string
-		dateTo            string
-		dateFrom          string
-	}
-	tests := []struct {
-		name  string
-		args  args
-		want  *model.Date
-		want1 *model.Date
-		want2 *model.Date
-	}{
-		{
-			name: "No dates passed in no dates are returned",
-			args: args{
-				dateOfTransaction: "",
-				dateTo:            "",
-				dateFrom:          "",
-			},
-			want:  nil,
-			want1: nil,
-			want2: nil,
-		},
-		{
-			name: "All dates passed in all dates are returned",
-			args: args{
-				dateOfTransaction: "01/01/2021",
-				dateTo:            "02/02/2022",
-				dateFrom:          "03/03/2023",
-			},
-			want:  &model.Date{Time: time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC)},
-			want1: &model.Date{Time: time.Date(2022, time.February, 2, 0, 0, 0, 0, time.UTC)},
-			want2: &model.Date{Time: time.Date(2023, time.March, 3, 0, 0, 0, 0, time.UTC)},
-		},
-		{
-			name: "Only one date passed in one date is returned",
-			args: args{
-				dateOfTransaction: "01/01/2021",
-				dateTo:            "",
-				dateFrom:          "",
-			},
-			want:  &model.Date{Time: time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC)},
-			want1: nil,
-			want2: nil,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, got1, got2 := NewDownload(tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
-			assert.Equalf(t, tt.want, got, "NewDownload(%v, %v, %v)", tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
-			assert.Equalf(t, tt.want1, got1, "NewDownload(%v, %v, %v)", tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
-			assert.Equalf(t, tt.want2, got2, "NewDownload(%v, %v, %v)", tt.args.dateOfTransaction, tt.args.dateTo, tt.args.dateFrom)
-		})
-	}
-}
diff --git a/internal/model/download.go b/internal/model/download.go
index e75e4ec..587685c 100644
--- a/internal/model/download.go
+++ b/internal/model/download.go
@@ -11,3 +11,31 @@ type Download struct {
 	FromDateField      *Date  `json:"fromDateField,omitempty"`
 	Email              string `json:"email"`
 }
+
+func NewDownload(reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateOfTransaction, dateTo, dateFrom, email string) Download {
+	download := Download{
+		ReportType:         reportType,
+		ReportJournalType:  reportJournalType,
+		ReportScheduleType: reportScheduleType,
+		ReportAccountType:  reportAccountType,
+		ReportDebtType:     reportDebtType,
+		Email:              email,
+	}
+
+	if dateOfTransaction != "" {
+		raisedDateFormatted := NewDate(dateOfTransaction)
+		download.DateOfTransaction = &raisedDateFormatted
+	}
+
+	if dateTo != "" {
+		startDateFormatted := NewDate(dateTo)
+		download.ToDateField = &startDateFormatted
+	}
+
+	if dateFrom != "" {
+		endDateFormatted := NewDate(dateFrom)
+		download.FromDateField = &endDateFormatted
+	}
+
+	return download
+}
diff --git a/internal/model/download_test.go b/internal/model/download_test.go
new file mode 100644
index 0000000..baf2e21
--- /dev/null
+++ b/internal/model/download_test.go
@@ -0,0 +1,99 @@
+package model
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+func TestNewDownload(t *testing.T) {
+	type args struct {
+		reportType         string
+		reportJournalType  string
+		reportScheduleType string
+		reportAccountType  string
+		reportDebtType     string
+		dateOfTransaction  string
+		dateTo             string
+		dateFrom           string
+		email              string
+	}
+
+	dateOfTransaction, _ := time.Parse("02/01/2006", "11/05/2024")
+	dateTo, _ := time.Parse("02/01/2006", "15/06/2025")
+	dateFrom, _ := time.Parse("02/01/2006", "21/07/2022")
+
+	tests := []struct {
+		name string
+		args args
+		want Download
+	}{
+		{
+			name: "Returns all fields",
+			args: args{
+				reportType:         "reportType",
+				reportJournalType:  "reportJournalType",
+				reportScheduleType: "reportScheduleType",
+				reportAccountType:  "reportAccountType",
+				reportDebtType:     "reportDebtType",
+				dateOfTransaction:  "11/05/2024",
+				dateTo:             "15/06/2025",
+				dateFrom:           "21/07/2022",
+				email:              "Something@example.com",
+			},
+			want: Download{
+				ReportType:         "reportType",
+				ReportJournalType:  "reportJournalType",
+				ReportScheduleType: "reportScheduleType",
+				ReportAccountType:  "reportAccountType",
+				ReportDebtType:     "reportDebtType",
+				DateOfTransaction:  &Date{dateOfTransaction},
+				ToDateField:        &Date{dateTo},
+				FromDateField:      &Date{dateFrom},
+				Email:              "Something@example.com",
+			},
+		},
+		{
+			name: "Returns with missing optional fields",
+			args: args{
+				reportType:         "reportType",
+				reportJournalType:  "reportJournalType",
+				reportScheduleType: "reportScheduleType",
+				reportAccountType:  "reportAccountType",
+				reportDebtType:     "reportDebtType",
+				dateOfTransaction:  "",
+				dateTo:             "",
+				dateFrom:           "",
+				email:              "Something@example.com",
+			},
+			want: Download{
+				ReportType:         "reportType",
+				ReportJournalType:  "reportJournalType",
+				ReportScheduleType: "reportScheduleType",
+				ReportAccountType:  "reportAccountType",
+				ReportDebtType:     "reportDebtType",
+				DateOfTransaction:  nil,
+				ToDateField:        nil,
+				FromDateField:      nil,
+				Email:              "Something@example.com",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := NewDownload(
+				tt.args.reportType,
+				tt.args.reportJournalType,
+				tt.args.reportScheduleType,
+				tt.args.reportAccountType,
+				tt.args.reportDebtType,
+				tt.args.dateOfTransaction,
+				tt.args.dateTo,
+				tt.args.dateFrom,
+				tt.args.email,
+			)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
diff --git a/internal/server/download.go b/internal/server/download.go
index fd781b9..e3af3f5 100644
--- a/internal/server/download.go
+++ b/internal/server/download.go
@@ -27,7 +27,8 @@ func (h *GetDownloadHandler) render(v AppVars, w http.ResponseWriter, r *http.Re
 		email              = params.Get("email")
 	)
 
-	err := h.Client().Download(ctx, reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateOfTransaction, dateFrom, dateTo, email)
+	data := model.NewDownload(reportType, reportJournalType, reportScheduleType, reportAccountType, reportDebtType, dateOfTransaction, dateTo, dateFrom, email)
+	err := h.Client().Download(ctx, data)
 
 	if err != nil {
 		var (
diff --git a/internal/server/server.go b/internal/server/server.go
index 6738293..e79a76b 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -4,6 +4,7 @@ import (
 	"github.com/ministryofjustice/opg-go-common/securityheaders"
 	"github.com/ministryofjustice/opg-go-common/telemetry"
 	"github.com/opg-sirius-finance-admin/internal/api"
+	"github.com/opg-sirius-finance-admin/internal/model"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"html/template"
 	"io"
@@ -14,7 +15,7 @@ import (
 )
 
 type ApiClient interface {
-	Download(api.Context, string, string, string, string, string, string, string, string, string) error
+	Download(api.Context, model.Download) error
 }
 
 type router interface {
diff --git a/internal/server/server_test.go b/internal/server/server_test.go
index 6ed88a4..3e6a7f0 100644
--- a/internal/server/server_test.go
+++ b/internal/server/server_test.go
@@ -2,6 +2,7 @@ package server
 
 import (
 	"github.com/opg-sirius-finance-admin/internal/api"
+	"github.com/opg-sirius-finance-admin/internal/model"
 	"io"
 	"net/http"
 )
@@ -51,6 +52,6 @@ type mockApiClient struct {
 	error error //nolint:golint,unused
 }
 
-func (m mockApiClient) Download(context api.Context, reportType string, reportJournalType string, reportScheduleType string, reportAccountType string, reportDebtType string, dateOfTransaction string, dateFrom string, dateTo string, email string) error {
+func (m mockApiClient) Download(context api.Context, data model.Download) error {
 	return m.error
 }

From a5ea7ec4c463460af6d204c894d29af03e2b5aa8 Mon Sep 17 00:00:00 2001
From: nicholassully <nicholas.sully@digital.justice.gov.uk>
Date: Thu, 29 Aug 2024 13:25:33 +0100
Subject: [PATCH 6/7] pfs-116 removed creating of a date model and tidy up
 validation errors

---
 internal/api/api_client_test.go |  1 -
 internal/api/download.go        |  4 +---
 internal/api/download_test.go   | 10 ++++------
 3 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/internal/api/api_client_test.go b/internal/api/api_client_test.go
index 65b1272..16d58f7 100644
--- a/internal/api/api_client_test.go
+++ b/internal/api/api_client_test.go
@@ -9,7 +9,6 @@ import (
 )
 
 type MockClient struct {
-	DoFunc func(req *http.Request) (*http.Response, error)
 }
 
 var (
diff --git a/internal/api/download.go b/internal/api/download.go
index f24cf56..b7e514e 100644
--- a/internal/api/download.go
+++ b/internal/api/download.go
@@ -49,9 +49,7 @@ func (c *Client) Download(ctx Context, data model.Download) error {
 
 		validationErrors := model.ValidationErrors{}
 		for _, reason := range badRequests.Reasons {
-			innerMap := make(map[string]string)
-			innerMap[reason] = reason
-			validationErrors[reason] = innerMap
+			validationErrors[reason] = map[string]string{reason: reason}
 		}
 
 		return model.ValidationError{Errors: validationErrors}
diff --git a/internal/api/download_test.go b/internal/api/download_test.go
index 6c028e3..6746dc7 100644
--- a/internal/api/download_test.go
+++ b/internal/api/download_test.go
@@ -4,21 +4,19 @@ import (
 	"bytes"
 	"encoding/json"
 	"github.com/opg-sirius-finance-admin/internal/model"
+	"github.com/stretchr/testify/assert"
 	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestSubmitDownload(t *testing.T) {
 	mockClient := &MockClient{}
 	client, _ := NewClient(mockClient, "http://localhost:3000", "")
-	dateOfTransaction := model.Date{Time: time.Date(2024, 5, 11, 0, 0, 0, 0, time.UTC)}
-	dateTo := model.Date{Time: time.Date(2025, 6, 15, 0, 0, 0, 0, time.UTC)}
-	dateFrom := model.Date{Time: time.Date(2022, 7, 21, 0, 0, 0, 0, time.UTC)}
+	dateOfTransaction := model.NewDate("2024-05-11")
+	dateTo := model.NewDate("2025-06-15")
+	dateFrom := model.NewDate("2022-07-21")
 
 	data := model.Download{
 		ReportType:         "reportType",

From 1cc81bde3fea3ca6179e45d21cbb103345b26f21 Mon Sep 17 00:00:00 2001
From: nicholassully <nicholas.sully@digital.justice.gov.uk>
Date: Mon, 9 Sep 2024 09:32:41 +0100
Subject: [PATCH 7/7] pfs-116 adding marshal and unmarshal funcs;

---
 internal/api/api_client.go       |  1 -
 internal/model/account_type.go   | 34 ++++++++++++++++++++
 internal/model/date_test.go      | 13 --------
 internal/model/debt_type.go      | 28 +++++++++++++++++
 internal/model/journal_type.go   | 32 +++++++++++++++++--
 internal/model/reports_type.go   | 30 ++++++++++++++++++
 internal/model/schedule_type.go  | 53 ++++++++++++++++++++++++++++++++
 internal/server/app_vars_test.go |  1 -
 internal/server/download_test.go |  1 -
 internal/server/route_test.go    |  1 -
 internal/server/server.go        |  4 ---
 11 files changed, 175 insertions(+), 23 deletions(-)

diff --git a/internal/api/api_client.go b/internal/api/api_client.go
index 3249b64..bb5b3af 100644
--- a/internal/api/api_client.go
+++ b/internal/api/api_client.go
@@ -11,7 +11,6 @@ type Context struct {
 	Context   context.Context
 	Cookies   []*http.Cookie
 	XSRFToken string
-	ClientId  int
 }
 
 const ErrUnauthorized ClientError = "unauthorized"
diff --git a/internal/model/account_type.go b/internal/model/account_type.go
index 9ddedd6..6d4bc8a 100644
--- a/internal/model/account_type.go
+++ b/internal/model/account_type.go
@@ -1,5 +1,7 @@
 package model
 
+import "encoding/json"
+
 var ReportAccountTypes = []ReportAccountType{
 	ReportAccountTypeAgedDebt,
 	ReportAccountTypeUnappliedReceipts,
@@ -11,6 +13,17 @@ var ReportAccountTypes = []ReportAccountType{
 	ReportAccountTypeFeeAccrual,
 }
 
+var reportAccountTypeMap = map[string]ReportAccountType{
+	"AgedDebt":                    ReportAccountTypeAgedDebt,
+	"UnappliedReceipts":           ReportAccountTypeUnappliedReceipts,
+	"CustomerAgeingBuckets":       ReportAccountTypeCustomerAgeingBuckets,
+	"ARPaidInvoiceReport":         ReportAccountTypeARPaidInvoiceReport,
+	"PaidInvoiceTransactionLines": ReportAccountTypePaidInvoiceTransactionLines,
+	"TotalReceiptsReport":         ReportAccountTypeTotalReceiptsReport,
+	"BadDebtWriteOffReport":       ReportAccountTypeBadDebtWriteOffReport,
+	"FeeAccrual":                  ReportAccountTypeFeeAccrual,
+}
+
 type ReportAccountType int
 
 const (
@@ -75,6 +88,27 @@ func (i ReportAccountType) Key() string {
 	}
 }
 
+func ParseReportAccountType(s string) ReportAccountType {
+	value, ok := reportAccountTypeMap[s]
+	if !ok {
+		return ReportAccountType(0)
+	}
+	return value
+}
+
 func (i ReportAccountType) Valid() bool {
 	return i != ReportAccountTypeUnknown
 }
+
+func (i ReportAccountType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(i.Key())
+}
+
+func (i *ReportAccountType) UnmarshalJSON(data []byte) (err error) {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+	*i = ParseReportAccountType(s)
+	return nil
+}
diff --git a/internal/model/date_test.go b/internal/model/date_test.go
index f5b2546..d504cad 100644
--- a/internal/model/date_test.go
+++ b/internal/model/date_test.go
@@ -5,25 +5,12 @@ import (
 	"github.com/stretchr/testify/assert"
 	"strconv"
 	"testing"
-	"time"
 )
 
 type testJsonDateStruct struct {
 	TestDate Date `json:"testDate"`
 }
 
-func TestNewDate(t *testing.T) {
-	want := Date{Time: time.Date(2020, 12, 31, 0, 0, 0, 0, time.UTC)}
-	assert.Equal(t, want, NewDate("31/12/2020"))
-
-	defer func() {
-		if r := recover(); r == nil {
-			t.Errorf("NewDate should panic with incorrect date format")
-		}
-	}()
-	NewDate("12/31/2020") // wrong format should trigger a panic
-}
-
 func TestDate_Before_And_After(t *testing.T) {
 	tests := []struct {
 		name              string
diff --git a/internal/model/debt_type.go b/internal/model/debt_type.go
index 51ce2ae..c053245 100644
--- a/internal/model/debt_type.go
+++ b/internal/model/debt_type.go
@@ -1,5 +1,7 @@
 package model
 
+import "encoding/json"
+
 var ReportDebtTypes = []ReportDebtType{
 	ReportDebtTypeFeeChase,
 	ReportDebtTypeFinalFee,
@@ -13,6 +15,11 @@ const (
 	ReportDebtTypeFinalFee
 )
 
+var reportDebtTypeMap = map[string]ReportDebtType{
+	"FeeChase": ReportDebtTypeFeeChase,
+	"FinalFee": ReportDebtTypeFinalFee,
+}
+
 func (i ReportDebtType) String() string {
 	return i.Key()
 }
@@ -39,6 +46,27 @@ func (i ReportDebtType) Key() string {
 	}
 }
 
+func ParseReportDebtType(s string) ReportDebtType {
+	value, ok := reportDebtTypeMap[s]
+	if !ok {
+		return ReportDebtType(0)
+	}
+	return value
+}
+
 func (i ReportDebtType) Valid() bool {
 	return i != ReportDebtTypeUnknown
 }
+
+func (i ReportDebtType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(i.Key())
+}
+
+func (i *ReportDebtType) UnmarshalJSON(data []byte) (err error) {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+	*i = ParseReportDebtType(s)
+	return nil
+}
diff --git a/internal/model/journal_type.go b/internal/model/journal_type.go
index eb8618e..3bc976c 100644
--- a/internal/model/journal_type.go
+++ b/internal/model/journal_type.go
@@ -1,18 +1,25 @@
 package model
 
+import "encoding/json"
+
 var ReportJournalTypes = []ReportJournalType{
 	ReportTypeReceiptTransactions,
 	ReportTypeNonReceiptTransactions,
 }
 
-type ReportJournalType int
-
 const (
 	ReportTypeUnknown ReportJournalType = iota
 	ReportTypeReceiptTransactions
 	ReportTypeNonReceiptTransactions
 )
 
+var reportJournalTypeMap = map[string]ReportJournalType{
+	"ReceiptTransactions":    ReportTypeReceiptTransactions,
+	"NonReceiptTransactions": ReportTypeNonReceiptTransactions,
+}
+
+type ReportJournalType int
+
 func (i ReportJournalType) String() string {
 	return i.Key()
 }
@@ -39,6 +46,27 @@ func (i ReportJournalType) Key() string {
 	}
 }
 
+func ParseReportJournalType(s string) ReportJournalType {
+	value, ok := reportJournalTypeMap[s]
+	if !ok {
+		return ReportJournalType(0)
+	}
+	return value
+}
+
 func (i ReportJournalType) Valid() bool {
 	return i != ReportTypeUnknown
 }
+
+func (i ReportJournalType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(i.Key())
+}
+
+func (i *ReportJournalType) UnmarshalJSON(data []byte) (err error) {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+	*i = ParseReportJournalType(s)
+	return nil
+}
diff --git a/internal/model/reports_type.go b/internal/model/reports_type.go
index d9e5463..119f73d 100644
--- a/internal/model/reports_type.go
+++ b/internal/model/reports_type.go
@@ -1,5 +1,7 @@
 package model
 
+import "encoding/json"
+
 var ReportsTypes = []ReportsType{
 	ReportsTypeJournal,
 	ReportsTypeSchedule,
@@ -17,6 +19,13 @@ const (
 	ReportsTypeDebt
 )
 
+var reportsTypeMap = map[string]ReportsType{
+	"Journal":            ReportsTypeJournal,
+	"Schedule":           ReportsTypeSchedule,
+	"AccountsReceivable": ReportsTypeAccountsReceivable,
+	"Debt":               ReportsTypeDebt,
+}
+
 func (i ReportsType) String() string {
 	return i.Key()
 }
@@ -51,6 +60,14 @@ func (i ReportsType) Key() string {
 	}
 }
 
+func ParseReportsType(s string) ReportsType {
+	value, ok := reportsTypeMap[s]
+	if !ok {
+		return ReportsType(0)
+	}
+	return value
+}
+
 func (i ReportsType) Valid() bool {
 	return i != ReportsTypeUnknown
 }
@@ -62,3 +79,16 @@ func (i ReportsType) RequiresDateValidation() bool {
 	}
 	return false
 }
+
+func (i ReportsType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(i.Key())
+}
+
+func (i *ReportsType) UnmarshalJSON(data []byte) (err error) {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+	*i = ParseReportsType(s)
+	return nil
+}
diff --git a/internal/model/schedule_type.go b/internal/model/schedule_type.go
index 3753424..9d8fae2 100644
--- a/internal/model/schedule_type.go
+++ b/internal/model/schedule_type.go
@@ -1,5 +1,7 @@
 package model
 
+import "encoding/json"
+
 var ReportScheduleTypes = []ReportScheduleType{
 	ReportTypeMOTOCardPayments,
 	ReportTypeOnlineCardPayments,
@@ -63,6 +65,36 @@ const (
 	ReportMinimalWriteOffReversals
 )
 
+var reportScheduleTypeMap = map[string]ReportScheduleType{
+	"Accounts Receivable":      ReportTypeMOTOCardPayments,
+	"OnlineCardPayments":       ReportTypeOnlineCardPayments,
+	"OPGBACSTransfer":          ReportOPGBACSTransfer,
+	"SupervisionBACSTransfer":  ReportSupervisionBACSTransfer,
+	"DirectDebitPayment":       ReportDirectDebitPayments,
+	"AdFeeInvoices":            ReportAdFeeInvoices,
+	"S2FeeInvoices":            ReportS2FeeInvoices,
+	"S3FeeInvoices":            ReportS3FeeInvoices,
+	"B2FeeInvoices":            ReportB2FeeInvoices,
+	"B3FeeInvoices":            ReportB3FeeInvoices,
+	"SFFeeInvoicesGeneral ":    ReportSFFeeInvoicesGeneral,
+	"SFFeeInvoicesMinimal":     ReportSFFeeInvoicesMinimal,
+	"SEFeeInvoicesGeneral":     ReportSEFeeInvoicesGeneral,
+	"SEFeeInvoicesMinimal":     ReportSEFeeInvoicesMinimal,
+	"SOFeeInvoicesGeneral":     ReportSOFeeInvoicesGeneral,
+	"SOFeeInvoicesMinimal":     ReportSOFeeInvoicesMinimal,
+	"ADFeeReductions":          ReportADFeeReductions,
+	"GeneralManualCredits":     ReportGeneralManualCredits,
+	"MinimalManualCredits":     ReportMinimalManualCredits,
+	"GeneralManualDebits":      ReportGeneralManualDebits,
+	"MinimalManualDebits":      ReportMinimalManualDebits,
+	"ADWrite-offs":             ReportADWriteOffs,
+	"GeneralWrite-offs":        ReportGeneralWriteOffs,
+	"MinimalWriteOffs":         ReportMinimalWriteOffs,
+	"ADWriteOffReversals":      ReportADWriteOffReversals,
+	"GeneralWriteOffReversals": ReportGeneralWriteOffReversals,
+	"MinimalWriteOffReversals": ReportMinimalWriteOffReversals,
+}
+
 func (i ReportScheduleType) String() string {
 	return i.Key()
 }
@@ -189,6 +221,27 @@ func (i ReportScheduleType) Key() string {
 	}
 }
 
+func ParseReportScheduleType(s string) ReportScheduleType {
+	value, ok := reportScheduleTypeMap[s]
+	if !ok {
+		return ReportScheduleType(0)
+	}
+	return value
+}
+
 func (i ReportScheduleType) Valid() bool {
 	return i != ReportScheduleTypeUnknown
 }
+
+func (i ReportScheduleType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(i.Key())
+}
+
+func (i *ReportScheduleType) UnmarshalJSON(data []byte) (err error) {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+	*i = ParseReportScheduleType(s)
+	return nil
+}
diff --git a/internal/server/app_vars_test.go b/internal/server/app_vars_test.go
index e49bcb7..a6cc57b 100644
--- a/internal/server/app_vars_test.go
+++ b/internal/server/app_vars_test.go
@@ -8,7 +8,6 @@ import (
 
 func TestNewAppVars(t *testing.T) {
 	r, _ := http.NewRequest("GET", "/path", nil)
-	r.SetPathValue("clientId", "1")
 	r.AddCookie(&http.Cookie{Name: "XSRF-TOKEN", Value: "abc123"})
 
 	envVars := EnvironmentVars{}
diff --git a/internal/server/download_test.go b/internal/server/download_test.go
index 935dba6..885484b 100644
--- a/internal/server/download_test.go
+++ b/internal/server/download_test.go
@@ -30,7 +30,6 @@ func TestDownloadSuccess(t *testing.T) {
 	w := httptest.NewRecorder()
 	r, _ := http.NewRequest(http.MethodPost, "/download", strings.NewReader(form.Encode()))
 	r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-	r.SetPathValue("clientId", "1")
 
 	appVars := AppVars{
 		Path: "/download",
diff --git a/internal/server/route_test.go b/internal/server/route_test.go
index f9eef06..f137007 100644
--- a/internal/server/route_test.go
+++ b/internal/server/route_test.go
@@ -42,7 +42,6 @@ func TestRoute_fullPage(t *testing.T) {
 
 	w := httptest.NewRecorder()
 	r, _ := http.NewRequest(http.MethodGet, "", nil)
-	r.SetPathValue("clientId", "1")
 
 	data := PageData{
 		Data: mockRouteData{
diff --git a/internal/server/server.go b/internal/server/server.go
index e79a76b..1157e6c 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -11,7 +11,6 @@ import (
 	"log/slog"
 	"net/http"
 	"net/url"
-	"strconv"
 )
 
 type ApiClient interface {
@@ -64,12 +63,9 @@ func getContext(r *http.Request) api.Context {
 		token = r.FormValue("xsrfToken")
 	}
 
-	clientId, _ := strconv.Atoi(r.PathValue("clientId"))
-
 	return api.Context{
 		Context:   r.Context(),
 		Cookies:   r.Cookies(),
 		XSRFToken: token,
-		ClientId:  clientId,
 	}
 }