feat: add query filters for transactions (#282)

morremeyer · web-flow · commit c1052415e324 · 2022-08-06T00:23:37.000+02:00
diff --git a/api/docs.go b/api/docs.go
@@ -1576,6 +1576,44 @@ const docTemplate = `{
                     "Transactions"
                 ],
                 "summary": "Get transactions",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Filter by note",
+                        "name": "note",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by budget ID",
+                        "name": "budget",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by source account ID",
+                        "name": "source",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by destination account ID",
+                        "name": "destination",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by envelope ID",
+                        "name": "envelope",
+                        "in": "query"
+                    },
+                    {
+                        "type": "boolean",
+                        "description": "Filter by reconcilication state",
+                        "name": "reconciled",
+                        "in": "query"
+                    }
+                ],
                 "responses": {
                     "200": {
                         "description": "OK",
diff --git a/api/swagger.json b/api/swagger.json
@@ -1564,6 +1564,44 @@
                     "Transactions"
                 ],
                 "summary": "Get transactions",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Filter by note",
+                        "name": "note",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by budget ID",
+                        "name": "budget",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by source account ID",
+                        "name": "source",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by destination account ID",
+                        "name": "destination",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "description": "Filter by envelope ID",
+                        "name": "envelope",
+                        "in": "query"
+                    },
+                    {
+                        "type": "boolean",
+                        "description": "Filter by reconcilication state",
+                        "name": "reconciled",
+                        "in": "query"
+                    }
+                ],
                 "responses": {
                     "200": {
                         "description": "OK",
diff --git a/api/swagger.yaml b/api/swagger.yaml
@@ -1619,6 +1619,31 @@ paths:
   /v1/transactions:
     get:
       description: Returns a list of transactions
+      parameters:
+      - description: Filter by note
+        in: query
+        name: note
+        type: string
+      - description: Filter by budget ID
+        in: query
+        name: budget
+        type: string
+      - description: Filter by source account ID
+        in: query
+        name: source
+        type: string
+      - description: Filter by destination account ID
+        in: query
+        name: destination
+        type: string
+      - description: Filter by envelope ID
+        in: query
+        name: envelope
+        type: string
+      - description: Filter by reconcilication state
+        in: query
+        name: reconciled
+        type: boolean
       produces:
       - application/json
       responses:
diff --git a/pkg/controllers/transaction.go b/pkg/controllers/transaction.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"time"
 
 	"github.com/envelope-zero/backend/internal/database"
 	"github.com/envelope-zero/backend/pkg/httputil"
@@ -30,6 +31,56 @@ type TransactionLinks struct {
 	Self string `json:"self" example:"https://example.com/api/v1/transactions/d430d7c3-d14c-4712-9336-ee56965a6673"`
 }
 
+type TransactionQueryFilter struct {
+	Date                 time.Time       `form:"date"`
+	Amount               decimal.Decimal `form:"amount"`
+	Note                 string          `form:"note"`
+	BudgetID             string          `form:"budget"`
+	SourceAccountID      string          `form:"source"`
+	DestinationAccountID string          `form:"destination"`
+	EnvelopeID           string          `form:"envelope"`
+	Reconciled           bool            `form:"reconciled"`
+}
+
+func (f TransactionQueryFilter) ToCreate(c *gin.Context) (models.TransactionCreate, error) {
+	budgetID, err := httputil.UUIDFromString(c, f.BudgetID)
+	if err != nil {
+		return models.TransactionCreate{}, err
+	}
+
+	sourceAccountID, err := httputil.UUIDFromString(c, f.SourceAccountID)
+	if err != nil {
+		return models.TransactionCreate{}, err
+	}
+
+	destinationAccountID, err := httputil.UUIDFromString(c, f.DestinationAccountID)
+	if err != nil {
+		return models.TransactionCreate{}, err
+	}
+
+	envelopeID, err := httputil.UUIDFromString(c, f.EnvelopeID)
+	if err != nil {
+		return models.TransactionCreate{}, err
+	}
+
+	// If the envelopeID is nil, use an actual nil, not uuid.Nil
+	var eID *uuid.UUID = nil
+	if envelopeID != uuid.Nil {
+		eID = &envelopeID
+	}
+
+	return models.TransactionCreate{
+		Date:                 f.Date,
+		Amount:               f.Amount,
+		Note:                 f.Note,
+		BudgetID:             budgetID,
+		SourceAccountID:      sourceAccountID,
+		DestinationAccountID: destinationAccountID,
+		EnvelopeID:           eID,
+		Reconciled:           f.Reconciled,
+	}, nil
+}
+
 // RegisterTransactionRoutes registers the routes for transactions with
 // the RouterGroup that is passed.
 func RegisterTransactionRoutes(r *gin.RouterGroup) {
@@ -142,10 +193,34 @@ func CreateTransaction(c *gin.Context) {
 // @Failure     404
 // @Failure     500 {object} httputil.HTTPError
 // @Router      /v1/transactions [get]
+// @Param       date        query time.Time       false "Filter by date"
+// @Param       amount      query decimal.Decimal false "Filter by amount"
+// @Param       note        query string          false "Filter by note"
+// @Param       budget      query string          false "Filter by budget ID"
+// @Param       source      query string          false "Filter by source account ID"
+// @Param       destination query string          false "Filter by destination account ID"
+// @Param       envelope    query string          false "Filter by envelope ID"
+// @Param       reconciled  query bool            false "Filter by reconcilication state"
 func GetTransactions(c *gin.Context) {
-	var transactions []models.Transaction
+	var filter TransactionQueryFilter
+	if err := c.Bind(&filter); err != nil {
+		httputil.ErrorInvalidQueryString(c)
+		return
+	}
+
+	// Get the fields set in the filter
+	queryFields := httputil.GetURLFields(c.Request.URL, filter)
 
-	database.DB.Order("date(date) DESC").Find(&transactions)
+	// Convert the QueryFilter to a Create struct
+	create, err := filter.ToCreate(c)
+	if err != nil {
+		return
+	}
+
+	var transactions []models.Transaction
+	database.DB.Order("date(date) DESC").Where(&models.Transaction{
+		TransactionCreate: create,
+	}, queryFields...).Find(&transactions)
 
 	// When there are no resources, we want an empty list, not null
 	// Therefore, we use make to create a slice with zero elements
diff --git a/pkg/controllers/transaction_test.go b/pkg/controllers/transaction_test.go
@@ -66,6 +66,100 @@ func (suite *TestSuiteEnv) TestGetTransactions() {
 	assert.Len(suite.T(), response.Data, 2)
 }
 
+func (suite *TestSuiteEnv) TestGetTransactionsInvalidQuery() {
+	tests := []string{
+		"budget=DefinitelyACat",
+		"source=MaybeADog",
+		"destination=OrARat?",
+		"envelope=NopeDefinitelyAMole",
+		"date=A long time ago",
+		"amount=Seventeen Cents",
+		"reconciled=I don't think so",
+	}
+
+	for _, tt := range tests {
+		suite.T().Run(tt, func(t *testing.T) {
+			recorder := test.Request(suite.T(), http.MethodGet, fmt.Sprintf("http://example.com/v1/transactions?%s", tt), "")
+			test.AssertHTTPStatus(suite.T(), http.StatusBadRequest, &recorder)
+		})
+	}
+}
+
+func (suite *TestSuiteEnv) TestGetTransactionsFilter() {
+	b := createTestBudget(suite.T(), models.BudgetCreate{})
+
+	a1 := createTestAccount(suite.T(), models.AccountCreate{BudgetID: b.Data.ID})
+	a2 := createTestAccount(suite.T(), models.AccountCreate{BudgetID: b.Data.ID})
+
+	c := createTestCategory(suite.T(), models.CategoryCreate{BudgetID: b.Data.ID})
+
+	e1 := createTestEnvelope(suite.T(), models.EnvelopeCreate{CategoryID: c.Data.ID})
+	e2 := createTestEnvelope(suite.T(), models.EnvelopeCreate{CategoryID: c.Data.ID})
+
+	e1ID := &e1.Data.ID
+	e2ID := &e2.Data.ID
+
+	_ = createTestTransaction(suite.T(), models.TransactionCreate{
+		Date:                 time.Date(2018, 9, 5, 17, 13, 29, 45256, time.UTC),
+		Amount:               decimal.NewFromFloat(2.718),
+		Note:                 "This was an important expense",
+		BudgetID:             b.Data.ID,
+		EnvelopeID:           e1ID,
+		SourceAccountID:      a1.Data.ID,
+		DestinationAccountID: a2.Data.ID,
+		Reconciled:           false,
+	})
+
+	_ = createTestTransaction(suite.T(), models.TransactionCreate{
+		Date:                 time.Date(2016, 5, 1, 14, 13, 25, 584575, time.UTC),
+		Amount:               decimal.NewFromFloat(11235.813),
+		Note:                 "Not important",
+		BudgetID:             b.Data.ID,
+		EnvelopeID:           e2ID,
+		SourceAccountID:      a2.Data.ID,
+		DestinationAccountID: a1.Data.ID,
+		Reconciled:           false,
+	})
+
+	_ = createTestTransaction(suite.T(), models.TransactionCreate{
+		Date:                 time.Date(2021, 2, 6, 5, 1, 0, 585, time.UTC),
+		Amount:               decimal.NewFromFloat(2.718),
+		Note:                 "",
+		BudgetID:             b.Data.ID,
+		EnvelopeID:           e1ID,
+		SourceAccountID:      a1.Data.ID,
+		DestinationAccountID: a2.Data.ID,
+		Reconciled:           true,
+	})
+
+	tests := []struct {
+		name  string
+		query string
+		len   int
+	}{
+		{"Exact Date", fmt.Sprintf("date=%s", time.Date(2021, 2, 6, 5, 1, 0, 585, time.UTC).Format(time.RFC3339Nano)), 1},
+		{"Exact Amount", fmt.Sprintf("amount=%s", decimal.NewFromFloat(2.718).String()), 2},
+		{"Note", "note=Not important", 1},
+		{"No note", "note=", 1},
+		{"Budget Match", fmt.Sprintf("budget=%s", b.Data.ID), 3},
+		{"Envelope 2", fmt.Sprintf("envelope=%s", e2.Data.ID), 1},
+		{"Non-existing Source Account", "source=3340a084-acf8-4cb4-8f86-9e7f88a86190", 0},
+		{"Destination Account", fmt.Sprintf("destination=%s", a2.Data.ID), 2},
+		{"Reconciled", "reconciled=false", 2},
+	}
+
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			var re controllers.TransactionListResponse
+			r := test.Request(t, http.MethodGet, fmt.Sprintf("/v1/transactions?%s", tt.query), "")
+			test.AssertHTTPStatus(t, http.StatusOK, &r)
+			test.DecodeResponse(t, &r, &re)
+
+			assert.Equal(t, tt.len, len(re.Data), "Request ID: %s", r.Result().Header.Get("x-request-id"))
+		})
+	}
+}
+
 func (suite *TestSuiteEnv) TestNoTransactionNotFound() {
 	recorder := test.Request(suite.T(), http.MethodGet, "http://example.com/v1/transactions/048b061f-3b6b-45ab-b0e9-0f38d2fff0c8", "")
 
@@ -121,7 +215,9 @@ func (suite *TestSuiteEnv) TestTransactionSorting() {
 	var transactions controllers.TransactionListResponse
 	test.DecodeResponse(suite.T(), &r, &transactions)
 
-	assert.Len(suite.T(), transactions.Data, 3, "There are not exactly three transactions")
+	if !assert.Len(suite.T(), transactions.Data, 3, "There are not exactly three transactions") {
+		assert.FailNow(suite.T(), "Number of transactions is wrong, aborting")
+	}
 	assert.Equal(suite.T(), tMarch.Data.Date, transactions.Data[0].Date, "The first transaction is not the March transaction")
 	assert.Equal(suite.T(), tFebrurary.Data.Date, transactions.Data[1].Date, "The second transaction is not the February transaction")
 	assert.Equal(suite.T(), tJanuary.Data.Date, transactions.Data[2].Date, "The third transaction is not the January transaction")
diff --git a/pkg/httputil/request.go b/pkg/httputil/request.go
@@ -33,13 +33,13 @@ func BindData(c *gin.Context, data interface{}) error {
 // Follow https://github.com/gin-gonic/gin/pull/3045 to see when this gets resolved.
 func UUIDFromString(c *gin.Context, s string) (uuid.UUID, error) {
 	if s == "" {
-		return uuid.UUID{}, nil
+		return uuid.Nil, nil
 	}
 
 	u, err := uuid.Parse(s)
 	if err != nil {
 		ErrorInvalidUUID(c)
-		return uuid.UUID{}, err
+		return uuid.Nil, err
 	}
 
 	return u, nil

Original file line number	Diff line number	Diff line change
`@@ -33,13 +33,13 @@ func BindData(c *gin.Context, data interface{}) error {`
`33`	`33`	`// Follow https://github.com/gin-gonic/gin/pull/3045 to see when this gets resolved.`
`34`	`34`	`func UUIDFromString(c *gin.Context, s string) (uuid.UUID, error) {`
`35`	`35`	`if s == "" {`
`36`		`- return uuid.UUID{}, nil`
	`36`	`+ return uuid.Nil, nil`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`u, err := uuid.Parse(s)`
`40`	`40`	`if err != nil {`
`41`	`41`	`ErrorInvalidUUID(c)`
`42`		`- return uuid.UUID{}, err`
	`42`	`+ return uuid.Nil, err`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`return u, nil`