375 lines
10 KiB
Go
375 lines
10 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"encoding/csv"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type YNABImport struct {
|
|
Context context.Context
|
|
accounts []Account
|
|
payees []Payee
|
|
categories []GetCategoriesRow
|
|
categoryGroups []CategoryGroup
|
|
queries *Queries
|
|
budgetID uuid.UUID
|
|
}
|
|
|
|
func NewYNABImport(context context.Context, q *Queries, budgetID uuid.UUID) (*YNABImport, error) {
|
|
accounts, err := q.GetAccounts(context, budgetID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
payees, err := q.GetPayees(context, budgetID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
categories, err := q.GetCategories(context, budgetID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
categoryGroups, err := q.GetCategoryGroups(context, budgetID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &YNABImport{
|
|
Context: context,
|
|
accounts: accounts,
|
|
payees: payees,
|
|
categories: categories,
|
|
categoryGroups: categoryGroups,
|
|
queries: q,
|
|
budgetID: budgetID,
|
|
}, nil
|
|
|
|
}
|
|
|
|
// ImportAssignments expects a TSV-file as exported by YNAB in the following format:
|
|
//"Month" "Category Group/Category" "Category Group" "Category" "Budgeted" "Activity" "Available"
|
|
//"Apr 2019" "Income: Next Month" "Income" "Next Month" 0,00€ 0,00€ 0,00€
|
|
//
|
|
// Activity and Available are not imported, since they are determined by the transactions and historic assignments
|
|
func (ynab *YNABImport) ImportAssignments(r io.Reader) error {
|
|
csv := csv.NewReader(r)
|
|
csv.Comma = '\t'
|
|
csv.LazyQuotes = true
|
|
|
|
csvData, err := csv.ReadAll()
|
|
if err != nil {
|
|
return fmt.Errorf("could not read from tsv: %w", err)
|
|
}
|
|
|
|
count := 0
|
|
for _, record := range csvData[1:] {
|
|
|
|
dateString := record[0]
|
|
date, err := time.Parse("Jan 2006", dateString)
|
|
if err != nil {
|
|
return fmt.Errorf("could not parse date %s: %w", dateString, err)
|
|
}
|
|
|
|
categoryGroup, categoryName := record[2], record[3] //also in 1 joined by :
|
|
category, err := ynab.GetCategory(categoryGroup, categoryName)
|
|
if err != nil {
|
|
return fmt.Errorf("could not get category %s/%s: %w", categoryGroup, categoryName, err)
|
|
}
|
|
|
|
amountString := record[4]
|
|
amount, err := GetAmount(amountString, "0,00€")
|
|
if err != nil {
|
|
return fmt.Errorf("could not parse amount %s: %w", amountString, err)
|
|
}
|
|
|
|
if amount.Int.Int64() == 0 {
|
|
continue
|
|
}
|
|
|
|
assignment := CreateAssignmentParams{
|
|
Date: date,
|
|
CategoryID: category.UUID,
|
|
Amount: amount,
|
|
}
|
|
_, err = ynab.queries.CreateAssignment(ynab.Context, assignment)
|
|
if err != nil {
|
|
return fmt.Errorf("could not save assignment %v: %w", assignment, err)
|
|
}
|
|
|
|
count++
|
|
}
|
|
|
|
fmt.Printf("Imported %d assignments\n", count)
|
|
|
|
return nil
|
|
}
|
|
|
|
type Transfer struct {
|
|
CreateTransactionParams
|
|
TransferToAccount *Account
|
|
FromAccount string
|
|
ToAccount string
|
|
}
|
|
|
|
// ImportTransactions expects a TSV-file as exported by YNAB in the following format:
|
|
|
|
func (ynab *YNABImport) ImportTransactions(r io.Reader) error {
|
|
csv := csv.NewReader(r)
|
|
csv.Comma = '\t'
|
|
csv.LazyQuotes = true
|
|
|
|
csvData, err := csv.ReadAll()
|
|
if err != nil {
|
|
return fmt.Errorf("could not read from tsv: %w", err)
|
|
}
|
|
|
|
var openTransfers []Transfer
|
|
|
|
count := 0
|
|
for _, record := range csvData[1:] {
|
|
accountName := record[0]
|
|
account, err := ynab.GetAccount(accountName)
|
|
if err != nil {
|
|
return fmt.Errorf("could not get account %s: %w", accountName, err)
|
|
}
|
|
|
|
//flag := record[1]
|
|
|
|
dateString := record[2]
|
|
date, err := time.Parse("02.01.2006", dateString)
|
|
if err != nil {
|
|
return fmt.Errorf("could not parse date %s: %w", dateString, err)
|
|
}
|
|
|
|
categoryGroup, categoryName := record[5], record[6] //also in 4 joined by :
|
|
category, err := ynab.GetCategory(categoryGroup, categoryName)
|
|
if err != nil {
|
|
return fmt.Errorf("could not get category %s/%s: %w", categoryGroup, categoryName, err)
|
|
}
|
|
|
|
memo := record[7]
|
|
|
|
outflow := record[8]
|
|
inflow := record[9]
|
|
amount, err := GetAmount(inflow, outflow)
|
|
if err != nil {
|
|
return fmt.Errorf("could not parse amount from (%s/%s): %w", inflow, outflow, err)
|
|
}
|
|
|
|
transaction := CreateTransactionParams{
|
|
Date: date,
|
|
Memo: memo,
|
|
AccountID: account.ID,
|
|
CategoryID: category,
|
|
Amount: amount,
|
|
}
|
|
|
|
payeeName := record[3]
|
|
if strings.HasPrefix(payeeName, "Transfer : ") {
|
|
// Transaction is a transfer to
|
|
transferToAccountName := payeeName[11:]
|
|
transferToAccount, err := ynab.GetAccount(transferToAccountName)
|
|
if err != nil {
|
|
return fmt.Errorf("Could not get transfer account %s: %w", transferToAccountName, err)
|
|
}
|
|
|
|
transfer := Transfer{
|
|
transaction,
|
|
transferToAccount,
|
|
accountName,
|
|
transferToAccountName,
|
|
}
|
|
|
|
found := false
|
|
for i, openTransfer := range openTransfers {
|
|
if openTransfer.TransferToAccount.ID != transfer.AccountID {
|
|
continue
|
|
}
|
|
if openTransfer.AccountID != transfer.TransferToAccount.ID {
|
|
continue
|
|
}
|
|
if openTransfer.Amount.GetFloat64() != -1*transfer.Amount.GetFloat64() {
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("Matched transfers from %s to %s over %f\n", account.Name, transferToAccount.Name, amount.GetFloat64())
|
|
openTransfers[i] = openTransfers[len(openTransfers)-1]
|
|
openTransfers = openTransfers[:len(openTransfers)-1]
|
|
found = true
|
|
|
|
groupID := uuid.New()
|
|
transfer.GroupID = uuid.NullUUID{UUID: groupID, Valid: true}
|
|
openTransfer.GroupID = uuid.NullUUID{UUID: groupID, Valid: true}
|
|
|
|
_, err = ynab.queries.CreateTransaction(ynab.Context, transfer.CreateTransactionParams)
|
|
if err != nil {
|
|
return fmt.Errorf("could not save transaction %v: %w", transfer.CreateTransactionParams, err)
|
|
}
|
|
_, err = ynab.queries.CreateTransaction(ynab.Context, openTransfer.CreateTransactionParams)
|
|
if err != nil {
|
|
return fmt.Errorf("could not save transaction %v: %w", openTransfer.CreateTransactionParams, err)
|
|
}
|
|
break
|
|
}
|
|
|
|
if !found {
|
|
openTransfers = append(openTransfers, transfer)
|
|
}
|
|
} else {
|
|
payeeID, err := ynab.GetPayee(payeeName)
|
|
if err != nil {
|
|
return fmt.Errorf("could not get payee %s: %w", payeeName, err)
|
|
}
|
|
transaction.PayeeID = payeeID
|
|
|
|
_, err = ynab.queries.CreateTransaction(ynab.Context, transaction)
|
|
if err != nil {
|
|
return fmt.Errorf("could not save transaction %v: %w", transaction, err)
|
|
}
|
|
}
|
|
|
|
//status := record[10]
|
|
|
|
count++
|
|
}
|
|
|
|
for _, openTransfer := range openTransfers {
|
|
fmt.Printf("Saving unmatched transfer from %s to %s on %s over %f as regular transaction\n", openTransfer.FromAccount, openTransfer.ToAccount, openTransfer.Date, openTransfer.Amount.GetFloat64())
|
|
_, err = ynab.queries.CreateTransaction(ynab.Context, openTransfer.CreateTransactionParams)
|
|
if err != nil {
|
|
return fmt.Errorf("could not save transaction %v: %w", openTransfer.CreateTransactionParams, err)
|
|
}
|
|
|
|
}
|
|
fmt.Printf("Imported %d transactions\n", count)
|
|
|
|
return nil
|
|
}
|
|
|
|
func trimLastChar(s string) string {
|
|
r, size := utf8.DecodeLastRuneInString(s)
|
|
if r == utf8.RuneError && (size == 0 || size == 1) {
|
|
size = 0
|
|
}
|
|
return s[:len(s)-size]
|
|
}
|
|
|
|
func GetAmount(inflow string, outflow string) (Numeric, error) {
|
|
// Remove trailing currency
|
|
inflow = strings.Replace(trimLastChar(inflow), ",", ".", 1)
|
|
outflow = strings.Replace(trimLastChar(outflow), ",", ".", 1)
|
|
|
|
num := Numeric{}
|
|
err := num.Set(inflow)
|
|
if err != nil {
|
|
return num, fmt.Errorf("Could not parse inflow %s: %w", inflow, err)
|
|
}
|
|
|
|
// if inflow is zero, use outflow
|
|
if num.Int.Int64() != 0 {
|
|
return num, nil
|
|
}
|
|
|
|
err = num.Set("-" + outflow)
|
|
if err != nil {
|
|
return num, fmt.Errorf("Could not parse outflow %s: %w", inflow, err)
|
|
}
|
|
return num, nil
|
|
}
|
|
|
|
func (ynab *YNABImport) GetAccount(name string) (*Account, error) {
|
|
for _, acc := range ynab.accounts {
|
|
if acc.Name == name {
|
|
return &acc, nil
|
|
}
|
|
}
|
|
|
|
account, err := ynab.queries.CreateAccount(ynab.Context, CreateAccountParams{Name: name, BudgetID: ynab.budgetID})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ynab.accounts = append(ynab.accounts, account)
|
|
return &account, nil
|
|
}
|
|
|
|
func (ynab *YNABImport) GetPayee(name string) (uuid.NullUUID, error) {
|
|
if name == "" {
|
|
return uuid.NullUUID{}, nil
|
|
}
|
|
|
|
for _, pay := range ynab.payees {
|
|
if pay.Name == name {
|
|
return uuid.NullUUID{UUID: pay.ID, Valid: true}, nil
|
|
}
|
|
}
|
|
|
|
payee, err := ynab.queries.CreatePayee(ynab.Context, CreatePayeeParams{Name: name, BudgetID: ynab.budgetID})
|
|
if err != nil {
|
|
return uuid.NullUUID{}, err
|
|
}
|
|
|
|
ynab.payees = append(ynab.payees, payee)
|
|
return uuid.NullUUID{UUID: payee.ID, Valid: true}, nil
|
|
}
|
|
|
|
func (ynab *YNABImport) GetCategory(group string, name string) (uuid.NullUUID, error) {
|
|
if group == "" || name == "" {
|
|
return uuid.NullUUID{}, nil
|
|
}
|
|
|
|
for _, category := range ynab.categories {
|
|
if category.Name == name && category.Group == group {
|
|
return uuid.NullUUID{UUID: category.ID, Valid: true}, nil
|
|
}
|
|
}
|
|
|
|
for _, categoryGroup := range ynab.categoryGroups {
|
|
if categoryGroup.Name == group {
|
|
createCategory := CreateCategoryParams{Name: name, CategoryGroupID: categoryGroup.ID}
|
|
category, err := ynab.queries.CreateCategory(ynab.Context, createCategory)
|
|
if err != nil {
|
|
return uuid.NullUUID{}, err
|
|
}
|
|
|
|
getCategory := GetCategoriesRow{
|
|
ID: category.ID,
|
|
CategoryGroupID: category.CategoryGroupID,
|
|
Name: category.Name,
|
|
Group: categoryGroup.Name,
|
|
}
|
|
ynab.categories = append(ynab.categories, getCategory)
|
|
return uuid.NullUUID{UUID: category.ID, Valid: true}, nil
|
|
}
|
|
}
|
|
|
|
categoryGroup, err := ynab.queries.CreateCategoryGroup(ynab.Context, CreateCategoryGroupParams{Name: group, BudgetID: ynab.budgetID})
|
|
if err != nil {
|
|
return uuid.NullUUID{}, err
|
|
}
|
|
ynab.categoryGroups = append(ynab.categoryGroups, categoryGroup)
|
|
|
|
category, err := ynab.queries.CreateCategory(ynab.Context, CreateCategoryParams{Name: name, CategoryGroupID: categoryGroup.ID})
|
|
if err != nil {
|
|
return uuid.NullUUID{}, err
|
|
}
|
|
|
|
getCategory := GetCategoriesRow{
|
|
ID: category.ID,
|
|
CategoryGroupID: category.CategoryGroupID,
|
|
Name: category.Name,
|
|
Group: categoryGroup.Name,
|
|
}
|
|
ynab.categories = append(ynab.categories, getCategory)
|
|
return uuid.NullUUID{UUID: category.ID, Valid: true}, nil
|
|
}
|