feat: add Match Rule import to YNAB4 importer (#830)

Author: morremeyer

pkg/importer/creator.go

@@ -2,6 +2,7 @@ package importer
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/envelope-zero/backend/v3/pkg/models"
 	"github.com/google/uuid"
@@ -34,6 +35,23 @@ func Create(db *gorm.DB, resources ParsedResources) (models.Budget, error) {
 		resources.Accounts[idx] = account
 	}
 
+	// Create Match Rules
+	for _, matchRule := range resources.MatchRules {
+		aIdx := slices.IndexFunc(resources.Accounts, func(a models.Account) bool { return a.Name == matchRule.Account })
+		if aIdx == -1 {
+			tx.Rollback()
+			return models.Budget{}, fmt.Errorf("the account '%s' specified in the Match Rule matching '%s' could not be found in the list of Accounts", matchRule.Account, matchRule.Match)
+		}
+
+		matchRule.MatchRule.AccountID = resources.Accounts[aIdx].ID
+
+		err := tx.Create(&matchRule.MatchRule).Error
+		if err != nil {
+			tx.Rollback()
+			return models.Budget{}, err
+		}
+	}
+
 	for cName, category := range resources.Categories {
 		category.Model.BudgetID = budget.ID
 

pkg/importer/parser/ynab4/parse.go

@@ -134,6 +134,38 @@ func parsePayees(resources *importer.ParsedResources, payees []Payee) IDToName {
 				ImportHash: helpers.Sha256String(payee.EntityID),
 			},
 		})
+
+		// Parse the Match Rules from the payee's rename conditions
+		for _, r := range payee.RenameConditions {
+			// Skip deleted rename conditions
+			if r.Deleted {
+				continue
+			}
+
+			// Determine the match string. Since EZ uses globs and YNAB4 has different
+			// operators, we translate between the two
+			var match string
+			switch r.Operator {
+			case "Is":
+				match = r.Operand
+			case "Contains":
+				match = fmt.Sprintf("*%s*", r.Operand)
+			case "StartsWith":
+				match = fmt.Sprintf("%s*", r.Operand)
+			case "EndsWith":
+				match = fmt.Sprintf("*%s", r.Operand)
+			}
+
+			resources.MatchRules = append(resources.MatchRules, importer.MatchRule{
+				Account: payee.Name,
+				MatchRule: models.MatchRule{
+					MatchRuleCreate: models.MatchRuleCreate{
+						Priority: 0,
+						Match:    match,
+					},
+				},
+			})
+		}
 	}
 
 	return idToNames

pkg/importer/parser/ynab4/parse_test.go

@@ -110,6 +110,13 @@ func TestParse(t *testing.T) {
 		testAccounts(t, accounts)
 	})
 
+	// Check MatchRules
+	var matchRules []models.MatchRule
+	db.Find(&matchRules)
+	t.Run("MatchRules", func(t *testing.T) {
+		testMatchRules(t, matchRules, accounts)
+	})
+
 	// Check categories
 	var categories []models.Category
 	db.Find(&categories)
@@ -214,6 +221,47 @@ func testAccounts(t *testing.T, accounts []models.Account) {
 	}
 }
 
+// testMatchRules tests all MatchRule resources.
+func testMatchRules(t *testing.T, matchRules []models.MatchRule, accounts []models.Account) {
+	assert.Len(t, matchRules, 5, "Number of MatchRules is wrong")
+
+	// Check MatchRule details
+	//
+	// Not checking priority because YNAB4 does not have priorities here
+	// Therefore we always set it to 0 on import
+	tests := []struct {
+		match   string
+		account string
+	}{
+		{"Mum*", "Parents"},
+		{"*& Dad", "Parents"},
+		{"My Parents", "Parents"},
+		{"Co", "Favorite Coffee Shop"},
+		{"*Coffee Shop*", "Favorite Coffee Shop"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.match, func(t *testing.T) {
+			// Find Account
+			aIdx := slices.IndexFunc(accounts, func(a models.Account) bool { return a.Name == tt.account })
+			if !assert.NotEqual(t, -1, aIdx, "No Account with the name the Match Rule is targeting") {
+				return
+			}
+
+			// Find Match Rule
+			mIdx := slices.IndexFunc(matchRules, func(m models.MatchRule) bool { return m.Match == tt.match })
+			if !assert.NotEqual(t, -1, mIdx, "No Match Rule with the match we are looking for") {
+				return
+			}
+
+			a := accounts[aIdx]
+			m := matchRules[mIdx]
+
+			assert.Equal(t, a.ID, m.AccountID, "Match Rule Account ID and actual Account ID do not match")
+		})
+	}
+}
+
 // testCategories tests all the categories for correct import.
 func testCategories(t *testing.T, categories []models.Category) {
 	// 3 categories, 1 (Rainy Day Funds) only has hidden envelopes

pkg/importer/types.go

@@ -15,6 +15,7 @@ type ParsedResources struct {
 	Allocations  []Allocation
 	Transactions []Transaction
 	MonthConfigs []MonthConfig
+	MatchRules   []MatchRule
 }
 
 type Category struct {
@@ -26,6 +27,12 @@ type Envelope struct {
 	Model models.Envelope
 }
 
+// MatchRule represents a MatchRule to be imported.
+type MatchRule struct {
+	models.MatchRule
+	Account string
+}
+
 type Allocation struct {
 	Model    models.Allocation
 	Category string // There is a category here since an envelope with the same name can exist for multiple categories