code refactor

pkg/converters/beancount/beancount_data.go

@@ -41,49 +41,49 @@ const (
 
 // beancountData defines the structure of beancount data
 type beancountData struct {
-	accounts     map[string]*beancountAccount
-	transactions []*beancountTransactionEntry
+	Accounts     map[string]*beancountAccount
+	Transactions []*beancountTransactionEntry
 }
 
 // beancountAccount defines the structure of beancount account
 type beancountAccount struct {
-	name        string
-	accountType beancountAccountType
-	openDate    string
-	closeDate   string
+	Name        string
+	AccountType beancountAccountType
+	OpenDate    string
+	CloseDate   string
 }
 
 // beancountTransactionEntry defines the structure of beancount transaction entry
 type beancountTransactionEntry struct {
-	date      string
-	directive beancountDirective
-	payee     string
-	narration string
-	postings  []*beancountPosting
-	tags      []string
-	links     []string
-	metadata  map[string]string
+	Date      string
+	Directive beancountDirective
+	Payee     string
+	Narration string
+	Postings  []*beancountPosting
+	Tags      []string
+	Links     []string
+	Metadata  map[string]string
 }
 
 // beancountPosting defines the structure of beancount transaction posting
 type beancountPosting struct {
-	account            string
-	amount             string
-	originalAmount     string
-	commodity          string
-	totalCost          string
-	totalCostCommodity string
-	price              string
-	priceCommodity     string
-	metadata           map[string]string
+	Account            string
+	Amount             string
+	OriginalAmount     string
+	Commodity          string
+	TotalCost          string
+	TotalCostCommodity string
+	Price              string
+	PriceCommodity     string
+	Metadata           map[string]string
 }
 
 func (a *beancountAccount) isOpeningBalanceEquityAccount() bool {
-	if a.accountType != beancountEquityAccountType {
+	if a.AccountType != beancountEquityAccountType {
 		return false
 	}
 
-	nameItems := strings.Split(a.name, string(beancountMetadataKeySuffix))
+	nameItems := strings.Split(a.Name, string(beancountMetadataKeySuffix))
 
 	if len(nameItems) != 2 {
 		return false

pkg/converters/beancount/beancount_data_reader.go

@@ -49,8 +49,8 @@ func (r *beancountDataReader) read(ctx core.Context) (*beancountData, error) {
 	}
 
 	data := &beancountData{
-		accounts:     make(map[string]*beancountAccount),
-		transactions: make([]*beancountTransactionEntry, 0),
+		Accounts:     make(map[string]*beancountAccount),
+		Transactions: make([]*beancountTransactionEntry, 0),
 	}
 
 	var err error
@@ -100,7 +100,7 @@ func (r *beancountDataReader) read(ctx core.Context) (*beancountData, error) {
 
 			if ('A' <= actualFirstItem[0] && actualFirstItem[0] <= 'Z') || actualFirstItem[0] == '!' { // transaction posting
 				if currentTransactionEntry != nil && currentTransactionPosting != nil {
-					currentTransactionEntry.postings = append(currentTransactionEntry.postings, currentTransactionPosting)
+					currentTransactionEntry.Postings = append(currentTransactionEntry.Postings, currentTransactionPosting)
 					currentTransactionPosting = nil
 				}
 
@@ -120,12 +120,12 @@ func (r *beancountDataReader) read(ctx core.Context) (*beancountData, error) {
 				metadataValue := metadata[1]
 
 				if currentTransactionPosting != nil {
-					if _, exists := currentTransactionPosting.metadata[metadataKey]; !exists {
-						currentTransactionPosting.metadata[metadataKey] = metadataValue
+					if _, exists := currentTransactionPosting.Metadata[metadataKey]; !exists {
+						currentTransactionPosting.Metadata[metadataKey] = metadataValue
 					}
 				} else if currentTransactionEntry != nil {
-					if _, exists := currentTransactionEntry.metadata[metadataKey]; !exists {
-						currentTransactionEntry.metadata[metadataKey] = metadataValue
+					if _, exists := currentTransactionEntry.Metadata[metadataKey]; !exists {
+						currentTransactionEntry.Metadata[metadataKey] = metadataValue
 					}
 				}
 			} else {
@@ -172,11 +172,11 @@ func (r *beancountDataReader) read(ctx core.Context) (*beancountData, error) {
 
 	if currentTransactionEntry != nil {
 		if currentTransactionPosting != nil {
-			currentTransactionEntry.postings = append(currentTransactionEntry.postings, currentTransactionPosting)
+			currentTransactionEntry.Postings = append(currentTransactionEntry.Postings, currentTransactionPosting)
 			currentTransactionPosting = nil
 		}
 
-		data.transactions = append(data.transactions, currentTransactionEntry)
+		data.Transactions = append(data.Transactions, currentTransactionEntry)
 		currentTransactionEntry = nil
 	}
 
@@ -186,11 +186,11 @@ func (r *beancountDataReader) read(ctx core.Context) (*beancountData, error) {
 func (r *beancountDataReader) updateCurrentState(data *beancountData, currentTransactionEntry *beancountTransactionEntry, currentTransactionPosting *beancountPosting) (*beancountTransactionEntry, *beancountPosting) {
 	if currentTransactionEntry != nil {
 		if currentTransactionPosting != nil {
-			currentTransactionEntry.postings = append(currentTransactionEntry.postings, currentTransactionPosting)
+			currentTransactionEntry.Postings = append(currentTransactionEntry.Postings, currentTransactionPosting)
 			currentTransactionPosting = nil
 		}
 
-		data.transactions = append(data.transactions, currentTransactionEntry)
+		data.Transactions = append(data.Transactions, currentTransactionEntry)
 		currentTransactionEntry = nil
 		currentTransactionPosting = nil
 	}
@@ -277,7 +277,7 @@ func (r *beancountDataReader) readAccountLine(ctx core.Context, lineIndex int, i
 
 	var err error
 	accountName := r.getNotEmptyItemByIndex(items, 2)
-	account, exists := data.accounts[accountName]
+	account, exists := data.Accounts[accountName]
 
 	if !exists {
 		account, err = r.createAccount(ctx, data, accountName)
@@ -288,10 +288,10 @@ func (r *beancountDataReader) readAccountLine(ctx core.Context, lineIndex int, i
 	}
 
 	if directive == beancountDirectiveOpen {
-		account.openDate = date
+		account.OpenDate = date
 		return account, nil
 	} else if directive == beancountDirectiveClose {
-		account.closeDate = date
+		account.CloseDate = date
 		return account, nil
 	} else {
 		log.Warnf(ctx, "[beancount_data_reader.parseAccount] cannot parse account line#%d \"%s\", because directive is invalid", lineIndex, strings.Join(items, " "))
@@ -301,8 +301,8 @@ func (r *beancountDataReader) readAccountLine(ctx core.Context, lineIndex int, i
 
 func (r *beancountDataReader) createAccount(ctx core.Context, data *beancountData, accountName string) (*beancountAccount, error) {
 	account := &beancountAccount{
-		name:        accountName,
-		accountType: beancountUnknownAccountType,
+		Name:        accountName,
+		AccountType: beancountUnknownAccountType,
 	}
 
 	accountNameItems := strings.Split(accountName, beancountAccountNameItemsSeparator)
@@ -311,31 +311,31 @@ func (r *beancountDataReader) createAccount(ctx core.Context, data *beancountDat
 		accountType, exists := r.accountTypeNameMap[accountNameItems[0]]
 
 		if exists {
-			account.accountType = accountType
+			account.AccountType = accountType
 		} else {
 			log.Warnf(ctx, "[beancount_data_reader.createAccount] cannot parse account \"%s\", because account type \"%s\" is invalid", accountName, accountNameItems[0])
 			return nil, errs.ErrInvalidBeancountFile
 		}
 	}
 
-	data.accounts[accountName] = account
+	data.Accounts[accountName] = account
 	return account, nil
 }
 
 func (r *beancountDataReader) readTransactionLine(ctx core.Context, lineIndex int, items []string, date string, directive beancountDirective, tags []string) *beancountTransactionEntry {
 	transactionEntry := &beancountTransactionEntry{
-		date:      date,
-		directive: directive,
-		tags:      make([]string, 0),
-		links:     make([]string, 0),
-		metadata:  make(map[string]string),
+		Date:      date,
+		Directive: directive,
+		Tags:      make([]string, 0),
+		Links:     make([]string, 0),
+		Metadata:  make(map[string]string),
 	}
 
-	transactionEntry.tags = append(transactionEntry.tags, tags...)
+	transactionEntry.Tags = append(transactionEntry.Tags, tags...)
 
-	allTags := make(map[string]bool, len(transactionEntry.tags))
+	allTags := make(map[string]bool, len(transactionEntry.Tags))
 
-	for _, tag := range transactionEntry.tags {
+	for _, tag := range transactionEntry.Tags {
 		allTags[tag] = true
 	}
 
@@ -363,7 +363,7 @@ func (r *beancountDataReader) readTransactionLine(ctx core.Context, lineIndex in
 			tagName := item[1:]
 
 			if _, exists := allTags[tagName]; !exists {
-				transactionEntry.tags = append(transactionEntry.tags, tagName)
+				transactionEntry.Tags = append(transactionEntry.Tags, tagName)
 				allTags[tagName] = true
 			}
 
@@ -371,7 +371,7 @@ func (r *beancountDataReader) readTransactionLine(ctx core.Context, lineIndex in
 				payeeNarrationLastIndex = i - 1
 			}
 		} else if item[0] == beancountLinkPrefix { // [ˆlink]
-			transactionEntry.links = append(transactionEntry.links, item[1:])
+			transactionEntry.Links = append(transactionEntry.Links, item[1:])
 
 			if i-1 < payeeNarrationLastIndex {
 				payeeNarrationLastIndex = i - 1
@@ -380,10 +380,10 @@ func (r *beancountDataReader) readTransactionLine(ctx core.Context, lineIndex in
 	}
 
 	if payeeNarrationLastIndex-payeeNarrationFirstIndex >= 1 {
-		transactionEntry.payee = items[payeeNarrationFirstIndex]
-		transactionEntry.narration = items[payeeNarrationFirstIndex+1]
+		transactionEntry.Payee = items[payeeNarrationFirstIndex]
+		transactionEntry.Narration = items[payeeNarrationFirstIndex+1]
 	} else if payeeNarrationLastIndex-payeeNarrationFirstIndex >= 0 {
-		transactionEntry.narration = items[payeeNarrationFirstIndex]
+		transactionEntry.Narration = items[payeeNarrationFirstIndex]
 	}
 
 	return transactionEntry
@@ -410,36 +410,36 @@ func (r *beancountDataReader) readTransactionPostingLine(ctx core.Context, lineI
 	}
 
 	transactionPositing := &beancountPosting{
-		account:  accountName,
-		metadata: make(map[string]string),
+		Account:  accountName,
+		Metadata: make(map[string]string),
 	}
 
 	amountActualLastIndex := -1
-	transactionPositing.originalAmount, amountActualLastIndex = r.getOriginalAmountAndLastIndexFromIndex(items, accountNameActualIndex+1)
+	transactionPositing.OriginalAmount, amountActualLastIndex = r.getOriginalAmountAndLastIndexFromIndex(items, accountNameActualIndex+1)
 
-	if transactionPositing.originalAmount == "" || amountActualLastIndex < 0 {
+	if transactionPositing.OriginalAmount == "" || amountActualLastIndex < 0 {
 		log.Warnf(ctx, "[beancount_data_reader.readTransactionPostingLine] cannot parse transaction posting line#%d \"%s\", because missing amount", lineIndex, strings.Join(items, " "))
 		return nil, errs.ErrAmountInvalid
 	}
 
-	finalAmount, err := evaluateBeancountAmountExpression(ctx, transactionPositing.originalAmount)
+	finalAmount, err := evaluateBeancountAmountExpression(ctx, transactionPositing.OriginalAmount)
 
 	if err != nil {
 		log.Warnf(ctx, "[beancount_data_reader.readTransactionPostingLine] cannot evaluate amount expression in line#%d \"%s\", because %s", lineIndex, strings.Join(items, " "), err.Error())
 		return nil, errs.ErrAmountInvalid
 	} else {
-		transactionPositing.amount = finalAmount
+		transactionPositing.Amount = finalAmount
 	}
 
 	commodityActualIndex := -1
-	transactionPositing.commodity, commodityActualIndex = r.getNotEmptyItemAndIndexFromIndex(items, amountActualLastIndex+1)
+	transactionPositing.Commodity, commodityActualIndex = r.getNotEmptyItemAndIndexFromIndex(items, amountActualLastIndex+1)
 
-	if transactionPositing.commodity == "" || commodityActualIndex < 0 {
+	if transactionPositing.Commodity == "" || commodityActualIndex < 0 {
 		log.Warnf(ctx, "[beancount_data_reader.readTransactionPostingLine] cannot parse transaction posting line#%d \"%s\", because missing commodity", lineIndex, strings.Join(items, " "))
 		return nil, errs.ErrInvalidBeancountFile
 	}
 
-	if strings.ToUpper(transactionPositing.commodity) != transactionPositing.commodity { // The syntax for a currency is a word all in capital letters
+	if strings.ToUpper(transactionPositing.Commodity) != transactionPositing.Commodity { // The syntax for a currency is a word all in capital letters
 		log.Warnf(ctx, "[beancount_data_reader.readTransactionPostingLine] cannot parse transaction posting line#%d \"%s\", because commodity name is not capital letters", lineIndex, strings.Join(items, " "))
 		return nil, errs.ErrInvalidBeancountFile
 	}
@@ -461,13 +461,13 @@ func (r *beancountDataReader) readTransactionPostingLine(ctx core.Context, lineI
 				totalCost, totalCostActualIndex := r.getNotEmptyItemAndIndexFromIndex(items, i+1)
 
 				if totalCostActualIndex > 0 {
-					transactionPositing.totalCost = totalCost
+					transactionPositing.TotalCost = totalCost
 					i = totalCostActualIndex
 
 					totalCostCommodity, totalCostCommodityActualIndex := r.getNotEmptyItemAndIndexFromIndex(items, totalCostActualIndex+1)
 
 					if totalCostCommodityActualIndex > 0 {
-						transactionPositing.totalCostCommodity = totalCostCommodity
+						transactionPositing.TotalCostCommodity = totalCostCommodity
 						i = totalCostCommodityActualIndex
 					}
 				}
@@ -475,13 +475,13 @@ func (r *beancountDataReader) readTransactionPostingLine(ctx core.Context, lineI
 				price, priceActualIndex := r.getNotEmptyItemAndIndexFromIndex(items, i+1)
 
 				if priceActualIndex > 0 {
-					transactionPositing.price = price
+					transactionPositing.Price = price
 					i = priceActualIndex
 
 					priceCommodity, priceCommodityActualIndex := r.getNotEmptyItemAndIndexFromIndex(items, priceActualIndex+1)
 
 					if priceCommodityActualIndex > 0 {
-						transactionPositing.priceCommodity = priceCommodity
+						transactionPositing.PriceCommodity = priceCommodity
 						i = priceCommodityActualIndex
 					}
 				}
@@ -489,11 +489,11 @@ func (r *beancountDataReader) readTransactionPostingLine(ctx core.Context, lineI
 		}
 	}
 
-	if transactionPositing.account != "" {
-		_, exists := data.accounts[transactionPositing.account]
+	if transactionPositing.Account != "" {
+		_, exists := data.Accounts[transactionPositing.Account]
 
 		if !exists {
-			_, err := r.createAccount(ctx, data, transactionPositing.account)
+			_, err := r.createAccount(ctx, data, transactionPositing.Account)
 
 			if err != nil {
 				return nil, err

pkg/converters/beancount/beancount_data_reader_test.go

@@ -41,56 +41,56 @@ func TestBeancountDataReaderRead(t *testing.T) {
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
 
-	assert.Equal(t, 5, len(actualData.accounts))
-	assert.Equal(t, "AssetsAccount:TestAccount", actualData.accounts["AssetsAccount:TestAccount"].name)
-	assert.Equal(t, beancountAssetsAccountType, actualData.accounts["AssetsAccount:TestAccount"].accountType)
-	assert.Equal(t, "2024-01-01", actualData.accounts["AssetsAccount:TestAccount"].openDate)
-	assert.Equal(t, "2024-01-07", actualData.accounts["AssetsAccount:TestAccount"].closeDate)
+	assert.Equal(t, 5, len(actualData.Accounts))
+	assert.Equal(t, "AssetsAccount:TestAccount", actualData.Accounts["AssetsAccount:TestAccount"].Name)
+	assert.Equal(t, beancountAssetsAccountType, actualData.Accounts["AssetsAccount:TestAccount"].AccountType)
+	assert.Equal(t, "2024-01-01", actualData.Accounts["AssetsAccount:TestAccount"].OpenDate)
+	assert.Equal(t, "2024-01-07", actualData.Accounts["AssetsAccount:TestAccount"].CloseDate)
 
-	assert.Equal(t, "LiabilitiesAccount:TestAccount2", actualData.accounts["LiabilitiesAccount:TestAccount2"].name)
-	assert.Equal(t, beancountLiabilitiesAccountType, actualData.accounts["LiabilitiesAccount:TestAccount2"].accountType)
-	assert.Equal(t, "2024-01-02", actualData.accounts["LiabilitiesAccount:TestAccount2"].openDate)
+	assert.Equal(t, "LiabilitiesAccount:TestAccount2", actualData.Accounts["LiabilitiesAccount:TestAccount2"].Name)
+	assert.Equal(t, beancountLiabilitiesAccountType, actualData.Accounts["LiabilitiesAccount:TestAccount2"].AccountType)
+	assert.Equal(t, "2024-01-02", actualData.Accounts["LiabilitiesAccount:TestAccount2"].OpenDate)
 
-	assert.Equal(t, 2, len(actualData.transactions))
+	assert.Equal(t, 2, len(actualData.Transactions))
 
-	assert.Equal(t, "2024-01-05", actualData.transactions[0].date)
-	assert.Equal(t, "Payee Name", actualData.transactions[0].payee)
-	assert.Equal(t, "Foo Bar", actualData.transactions[0].narration)
-	assert.Equal(t, 2, len(actualData.transactions[0].postings))
-	assert.Equal(t, "IncomeAccount:TestCategory", actualData.transactions[0].postings[0].account)
-	assert.Equal(t, "-123.45", actualData.transactions[0].postings[0].amount)
-	assert.Equal(t, "CNY", actualData.transactions[0].postings[0].commodity)
-	assert.Equal(t, "AssetsAccount:TestAccount", actualData.transactions[0].postings[1].account)
-	assert.Equal(t, "123.45", actualData.transactions[0].postings[1].amount)
-	assert.Equal(t, "CNY", actualData.transactions[0].postings[1].commodity)
+	assert.Equal(t, "2024-01-05", actualData.Transactions[0].Date)
+	assert.Equal(t, "Payee Name", actualData.Transactions[0].Payee)
+	assert.Equal(t, "Foo Bar", actualData.Transactions[0].Narration)
+	assert.Equal(t, 2, len(actualData.Transactions[0].Postings))
+	assert.Equal(t, "IncomeAccount:TestCategory", actualData.Transactions[0].Postings[0].Account)
+	assert.Equal(t, "-123.45", actualData.Transactions[0].Postings[0].Amount)
+	assert.Equal(t, "CNY", actualData.Transactions[0].Postings[0].Commodity)
+	assert.Equal(t, "AssetsAccount:TestAccount", actualData.Transactions[0].Postings[1].Account)
+	assert.Equal(t, "123.45", actualData.Transactions[0].Postings[1].Amount)
+	assert.Equal(t, "CNY", actualData.Transactions[0].Postings[1].Commodity)
 
-	assert.Equal(t, 4, len(actualData.transactions[0].tags))
-	assert.Equal(t, actualData.transactions[0].tags[0], "tag1")
-	assert.Equal(t, actualData.transactions[0].tags[1], "tag2")
-	assert.Equal(t, actualData.transactions[0].tags[2], "tag3")
-	assert.Equal(t, actualData.transactions[0].tags[3], "tag4")
+	assert.Equal(t, 4, len(actualData.Transactions[0].Tags))
+	assert.Equal(t, actualData.Transactions[0].Tags[0], "tag1")
+	assert.Equal(t, actualData.Transactions[0].Tags[1], "tag2")
+	assert.Equal(t, actualData.Transactions[0].Tags[2], "tag3")
+	assert.Equal(t, actualData.Transactions[0].Tags[3], "tag4")
 
-	assert.Equal(t, 1, len(actualData.transactions[0].links))
-	assert.Equal(t, actualData.transactions[0].links[0], "test-link")
+	assert.Equal(t, 1, len(actualData.Transactions[0].Links))
+	assert.Equal(t, actualData.Transactions[0].Links[0], "test-link")
 
-	assert.Equal(t, "2024-01-06", actualData.transactions[1].date)
-	assert.Equal(t, "", actualData.transactions[1].payee)
-	assert.Equal(t, "test\n#test2", actualData.transactions[1].narration)
-	assert.Equal(t, 2, len(actualData.transactions[1].postings))
-	assert.Equal(t, "LiabilitiesAccount:TestAccount2", actualData.transactions[1].postings[0].account)
-	assert.Equal(t, "-0.12", actualData.transactions[1].postings[0].amount)
-	assert.Equal(t, "USD", actualData.transactions[1].postings[0].commodity)
-	assert.Equal(t, "ExpensesAccount:TestCategory2", actualData.transactions[1].postings[1].account)
-	assert.Equal(t, "0.12", actualData.transactions[1].postings[1].amount)
-	assert.Equal(t, "USD", actualData.transactions[1].postings[1].commodity)
+	assert.Equal(t, "2024-01-06", actualData.Transactions[1].Date)
+	assert.Equal(t, "", actualData.Transactions[1].Payee)
+	assert.Equal(t, "test\n#test2", actualData.Transactions[1].Narration)
+	assert.Equal(t, 2, len(actualData.Transactions[1].Postings))
+	assert.Equal(t, "LiabilitiesAccount:TestAccount2", actualData.Transactions[1].Postings[0].Account)
+	assert.Equal(t, "-0.12", actualData.Transactions[1].Postings[0].Amount)
+	assert.Equal(t, "USD", actualData.Transactions[1].Postings[0].Commodity)
+	assert.Equal(t, "ExpensesAccount:TestCategory2", actualData.Transactions[1].Postings[1].Account)
+	assert.Equal(t, "0.12", actualData.Transactions[1].Postings[1].Amount)
+	assert.Equal(t, "USD", actualData.Transactions[1].Postings[1].Commodity)
 
-	assert.Equal(t, 3, len(actualData.transactions[1].tags))
-	assert.Equal(t, actualData.transactions[1].tags[0], "tag2")
-	assert.Equal(t, actualData.transactions[1].tags[1], "tag5")
-	assert.Equal(t, actualData.transactions[1].tags[2], "tag6")
+	assert.Equal(t, 3, len(actualData.Transactions[1].Tags))
+	assert.Equal(t, actualData.Transactions[1].Tags[0], "tag2")
+	assert.Equal(t, actualData.Transactions[1].Tags[1], "tag5")
+	assert.Equal(t, actualData.Transactions[1].Tags[2], "tag6")
 
-	assert.Equal(t, 1, len(actualData.transactions[1].links))
-	assert.Equal(t, actualData.transactions[1].links[0], "test-link2")
+	assert.Equal(t, 1, len(actualData.Transactions[1].Links))
+	assert.Equal(t, actualData.Transactions[1].Links[0], "test-link2")
 }
 
 func TestBeancountDataReaderRead_EmptyContent(t *testing.T) {
@@ -147,17 +147,17 @@ func TestBeancountDataReaderReadAndSetOption_AccountTypeName(t *testing.T) {
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
 
-	assert.Equal(t, 3, len(actualData.accounts))
+	assert.Equal(t, 3, len(actualData.Accounts))
 
-	assert.Equal(t, "A:TestAccount", actualData.accounts["A:TestAccount"].name)
-	assert.Equal(t, beancountAssetsAccountType, actualData.accounts["A:TestAccount"].accountType)
+	assert.Equal(t, "A:TestAccount", actualData.Accounts["A:TestAccount"].Name)
+	assert.Equal(t, beancountAssetsAccountType, actualData.Accounts["A:TestAccount"].AccountType)
 
-	assert.Equal(t, "L:TestAccount2", actualData.accounts["L:TestAccount2"].name)
-	assert.Equal(t, beancountLiabilitiesAccountType, actualData.accounts["L:TestAccount2"].accountType)
+	assert.Equal(t, "L:TestAccount2", actualData.Accounts["L:TestAccount2"].Name)
+	assert.Equal(t, beancountLiabilitiesAccountType, actualData.Accounts["L:TestAccount2"].AccountType)
 
-	assert.Equal(t, "E:Opening-Balances", actualData.accounts["E:Opening-Balances"].name)
-	assert.Equal(t, beancountEquityAccountType, actualData.accounts["E:Opening-Balances"].accountType)
-	assert.True(t, actualData.accounts["E:Opening-Balances"].isOpeningBalanceEquityAccount())
+	assert.Equal(t, "E:Opening-Balances", actualData.Accounts["E:Opening-Balances"].Name)
+	assert.Equal(t, beancountEquityAccountType, actualData.Accounts["E:Opening-Balances"].AccountType)
+	assert.True(t, actualData.Accounts["E:Opening-Balances"].isOpeningBalanceEquityAccount())
 }
 
 func TestBeancountDataReaderReadAndSetOption_InvalidLineOrUnsupportedOption(t *testing.T) {
@@ -203,31 +203,31 @@ func TestBeancountDataReaderReadAndSetTags(t *testing.T) {
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
 
-	assert.Equal(t, 5, len(actualData.transactions))
+	assert.Equal(t, 5, len(actualData.Transactions))
 
-	assert.Equal(t, 4, len(actualData.transactions[0].tags))
-	assert.Equal(t, actualData.transactions[0].tags[0], "tag1")
-	assert.Equal(t, actualData.transactions[0].tags[1], "tag2")
-	assert.Equal(t, actualData.transactions[0].tags[2], "tag3")
-	assert.Equal(t, actualData.transactions[0].tags[3], "tag4")
+	assert.Equal(t, 4, len(actualData.Transactions[0].Tags))
+	assert.Equal(t, actualData.Transactions[0].Tags[0], "tag1")
+	assert.Equal(t, actualData.Transactions[0].Tags[1], "tag2")
+	assert.Equal(t, actualData.Transactions[0].Tags[2], "tag3")
+	assert.Equal(t, actualData.Transactions[0].Tags[3], "tag4")
 
-	assert.Equal(t, 2, len(actualData.transactions[1].tags))
-	assert.Equal(t, actualData.transactions[1].tags[0], "tag5")
-	assert.Equal(t, actualData.transactions[1].tags[1], "tag6")
+	assert.Equal(t, 2, len(actualData.Transactions[1].Tags))
+	assert.Equal(t, actualData.Transactions[1].Tags[0], "tag5")
+	assert.Equal(t, actualData.Transactions[1].Tags[1], "tag6")
 
-	assert.Equal(t, 2, len(actualData.transactions[2].tags))
-	assert.Equal(t, actualData.transactions[2].tags[0], "tag5")
-	assert.Equal(t, actualData.transactions[2].tags[1], "tag6")
+	assert.Equal(t, 2, len(actualData.Transactions[2].Tags))
+	assert.Equal(t, actualData.Transactions[2].Tags[0], "tag5")
+	assert.Equal(t, actualData.Transactions[2].Tags[1], "tag6")
 
-	assert.Equal(t, 3, len(actualData.transactions[3].tags))
-	assert.Equal(t, actualData.transactions[3].tags[0], "tag3")
-	assert.Equal(t, actualData.transactions[3].tags[1], "tag6")
-	assert.Equal(t, actualData.transactions[3].tags[2], "tag5")
+	assert.Equal(t, 3, len(actualData.Transactions[3].Tags))
+	assert.Equal(t, actualData.Transactions[3].Tags[0], "tag3")
+	assert.Equal(t, actualData.Transactions[3].Tags[1], "tag6")
+	assert.Equal(t, actualData.Transactions[3].Tags[2], "tag5")
 
-	assert.Equal(t, 3, len(actualData.transactions[4].tags))
-	assert.Equal(t, actualData.transactions[4].tags[0], "tag3")
-	assert.Equal(t, actualData.transactions[4].tags[1], "tag6")
-	assert.Equal(t, actualData.transactions[4].tags[2], "tag5")
+	assert.Equal(t, 3, len(actualData.Transactions[4].Tags))
+	assert.Equal(t, actualData.Transactions[4].Tags[0], "tag3")
+	assert.Equal(t, actualData.Transactions[4].Tags[1], "tag6")
+	assert.Equal(t, actualData.Transactions[4].Tags[2], "tag5")
 }
 
 func TestBeancountDataReaderReadAccountLine_InvalidLine(t *testing.T) {
@@ -238,7 +238,7 @@ func TestBeancountDataReaderReadAccountLine_InvalidLine(t *testing.T) {
 
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
-	assert.Equal(t, 0, len(actualData.accounts))
+	assert.Equal(t, 0, len(actualData.Accounts))
 }
 
 func TestBeancountDataReaderReadAccountLine_InvalidAccountType(t *testing.T) {
@@ -274,44 +274,44 @@ func TestBeancountDataReaderReadTransactionLine(t *testing.T) {
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
 
-	assert.Equal(t, 6, len(actualData.transactions))
+	assert.Equal(t, 6, len(actualData.Transactions))
 
-	assert.Equal(t, "2024-01-01", actualData.transactions[0].date)
-	assert.Equal(t, beancountDirectiveCompletedTransaction, actualData.transactions[0].directive)
-	assert.Equal(t, "", actualData.transactions[0].payee)
-	assert.Equal(t, "", actualData.transactions[0].narration)
+	assert.Equal(t, "2024-01-01", actualData.Transactions[0].Date)
+	assert.Equal(t, beancountDirectiveCompletedTransaction, actualData.Transactions[0].Directive)
+	assert.Equal(t, "", actualData.Transactions[0].Payee)
+	assert.Equal(t, "", actualData.Transactions[0].Narration)
 
-	assert.Equal(t, "2024-01-02", actualData.transactions[1].date)
-	assert.Equal(t, beancountDirectiveCompletedTransaction, actualData.transactions[1].directive)
-	assert.Equal(t, "", actualData.transactions[1].payee)
-	assert.Equal(t, "test\ttest2\ntest3", actualData.transactions[1].narration)
+	assert.Equal(t, "2024-01-02", actualData.Transactions[1].Date)
+	assert.Equal(t, beancountDirectiveCompletedTransaction, actualData.Transactions[1].Directive)
+	assert.Equal(t, "", actualData.Transactions[1].Payee)
+	assert.Equal(t, "test\ttest2\ntest3", actualData.Transactions[1].Narration)
 
-	assert.Equal(t, "2024-01-03", actualData.transactions[2].date)
-	assert.Equal(t, beancountDirectiveInCompleteTransaction, actualData.transactions[2].directive)
-	assert.Equal(t, "test", actualData.transactions[2].payee)
-	assert.Equal(t, "test2", actualData.transactions[2].narration)
+	assert.Equal(t, "2024-01-03", actualData.Transactions[2].Date)
+	assert.Equal(t, beancountDirectiveInCompleteTransaction, actualData.Transactions[2].Directive)
+	assert.Equal(t, "test", actualData.Transactions[2].Payee)
+	assert.Equal(t, "test2", actualData.Transactions[2].Narration)
 
-	assert.Equal(t, "2024-01-04", actualData.transactions[3].date)
-	assert.Equal(t, beancountDirectivePaddingTransaction, actualData.transactions[3].directive)
-	assert.Equal(t, "", actualData.transactions[3].payee)
-	assert.Equal(t, "test", actualData.transactions[3].narration)
+	assert.Equal(t, "2024-01-04", actualData.Transactions[3].Date)
+	assert.Equal(t, beancountDirectivePaddingTransaction, actualData.Transactions[3].Directive)
+	assert.Equal(t, "", actualData.Transactions[3].Payee)
+	assert.Equal(t, "test", actualData.Transactions[3].Narration)
 
-	assert.Equal(t, 2, len(actualData.transactions[3].tags))
-	assert.Equal(t, actualData.transactions[3].tags[0], "tag")
-	assert.Equal(t, actualData.transactions[3].tags[1], "tag2")
+	assert.Equal(t, 2, len(actualData.Transactions[3].Tags))
+	assert.Equal(t, actualData.Transactions[3].Tags[0], "tag")
+	assert.Equal(t, actualData.Transactions[3].Tags[1], "tag2")
 
-	assert.Equal(t, "2024-01-05", actualData.transactions[4].date)
-	assert.Equal(t, beancountDirectiveTransaction, actualData.transactions[4].directive)
-	assert.Equal(t, "", actualData.transactions[4].payee)
-	assert.Equal(t, "test", actualData.transactions[4].narration)
+	assert.Equal(t, "2024-01-05", actualData.Transactions[4].Date)
+	assert.Equal(t, beancountDirectiveTransaction, actualData.Transactions[4].Directive)
+	assert.Equal(t, "", actualData.Transactions[4].Payee)
+	assert.Equal(t, "test", actualData.Transactions[4].Narration)
 
-	assert.Equal(t, 1, len(actualData.transactions[4].links))
-	assert.Equal(t, actualData.transactions[4].links[0], "scheme://path/to/test/link")
+	assert.Equal(t, 1, len(actualData.Transactions[4].Links))
+	assert.Equal(t, actualData.Transactions[4].Links[0], "scheme://path/to/test/link")
 
-	assert.Equal(t, "2024-01-06", actualData.transactions[5].date)
-	assert.Equal(t, beancountDirectiveTransaction, actualData.transactions[5].directive)
-	assert.Equal(t, "", actualData.transactions[5].payee)
-	assert.Equal(t, "", actualData.transactions[5].narration)
+	assert.Equal(t, "2024-01-06", actualData.Transactions[5].Date)
+	assert.Equal(t, beancountDirectiveTransaction, actualData.Transactions[5].Directive)
+	assert.Equal(t, "", actualData.Transactions[5].Payee)
+	assert.Equal(t, "", actualData.Transactions[5].Narration)
 }
 
 func TestBeancountDataReaderReadTransactionPostingLine(t *testing.T) {
@@ -331,39 +331,39 @@ func TestBeancountDataReaderReadTransactionPostingLine(t *testing.T) {
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
 
-	assert.Equal(t, 2, len(actualData.transactions))
+	assert.Equal(t, 2, len(actualData.Transactions))
 
-	assert.Equal(t, "2024-01-01", actualData.transactions[0].date)
-	assert.Equal(t, 2, len(actualData.transactions[0].postings))
-	assert.Equal(t, "Income:TestCategory", actualData.transactions[0].postings[0].account)
-	assert.Equal(t, "-123.45", actualData.transactions[0].postings[0].amount)
-	assert.Equal(t, "CNY", actualData.transactions[0].postings[0].commodity)
+	assert.Equal(t, "2024-01-01", actualData.Transactions[0].Date)
+	assert.Equal(t, 2, len(actualData.Transactions[0].Postings))
+	assert.Equal(t, "Income:TestCategory", actualData.Transactions[0].Postings[0].Account)
+	assert.Equal(t, "-123.45", actualData.Transactions[0].Postings[0].Amount)
+	assert.Equal(t, "CNY", actualData.Transactions[0].Postings[0].Commodity)
 
-	assert.Equal(t, "Assets:TestAccount", actualData.transactions[0].postings[1].account)
-	assert.Equal(t, "123.45", actualData.transactions[0].postings[1].amount)
-	assert.Equal(t, "CNY", actualData.transactions[0].postings[1].commodity)
+	assert.Equal(t, "Assets:TestAccount", actualData.Transactions[0].Postings[1].Account)
+	assert.Equal(t, "123.45", actualData.Transactions[0].Postings[1].Amount)
+	assert.Equal(t, "CNY", actualData.Transactions[0].Postings[1].Commodity)
 
-	assert.Equal(t, "2024-01-02", actualData.transactions[1].date)
-	assert.Equal(t, 4, len(actualData.transactions[1].postings))
+	assert.Equal(t, "2024-01-02", actualData.Transactions[1].Date)
+	assert.Equal(t, 4, len(actualData.Transactions[1].Postings))
 
-	assert.Equal(t, "Liabilities:TestAccount2", actualData.transactions[1].postings[0].account)
-	assert.Equal(t, "-0.23", actualData.transactions[1].postings[0].amount)
-	assert.Equal(t, "USD", actualData.transactions[1].postings[0].commodity)
-	assert.Equal(t, "Expenses:TestCategory2", actualData.transactions[1].postings[1].account)
+	assert.Equal(t, "Liabilities:TestAccount2", actualData.Transactions[1].Postings[0].Account)
+	assert.Equal(t, "-0.23", actualData.Transactions[1].Postings[0].Amount)
+	assert.Equal(t, "USD", actualData.Transactions[1].Postings[0].Commodity)
+	assert.Equal(t, "Expenses:TestCategory2", actualData.Transactions[1].Postings[1].Account)
 
-	assert.Equal(t, "0.12", actualData.transactions[1].postings[1].amount)
-	assert.Equal(t, "USD", actualData.transactions[1].postings[1].commodity)
-	assert.Equal(t, "0.84", actualData.transactions[1].postings[1].totalCost)
-	assert.Equal(t, "CNY", actualData.transactions[1].postings[1].totalCostCommodity)
-	assert.Equal(t, "Expenses:TestCategory3", actualData.transactions[1].postings[2].account)
+	assert.Equal(t, "0.12", actualData.Transactions[1].Postings[1].Amount)
+	assert.Equal(t, "USD", actualData.Transactions[1].Postings[1].Commodity)
+	assert.Equal(t, "0.84", actualData.Transactions[1].Postings[1].TotalCost)
+	assert.Equal(t, "CNY", actualData.Transactions[1].Postings[1].TotalCostCommodity)
+	assert.Equal(t, "Expenses:TestCategory3", actualData.Transactions[1].Postings[2].Account)
 
-	assert.Equal(t, "0.11", actualData.transactions[1].postings[2].amount)
-	assert.Equal(t, "USD", actualData.transactions[1].postings[2].commodity)
-	assert.Equal(t, "7.12", actualData.transactions[1].postings[2].price)
-	assert.Equal(t, "CNY", actualData.transactions[1].postings[2].priceCommodity)
+	assert.Equal(t, "0.11", actualData.Transactions[1].Postings[2].Amount)
+	assert.Equal(t, "USD", actualData.Transactions[1].Postings[2].Commodity)
+	assert.Equal(t, "7.12", actualData.Transactions[1].Postings[2].Price)
+	assert.Equal(t, "CNY", actualData.Transactions[1].Postings[2].PriceCommodity)
 
-	assert.Equal(t, "0.00", actualData.transactions[1].postings[3].amount)
-	assert.Equal(t, "USD", actualData.transactions[1].postings[3].commodity)
+	assert.Equal(t, "0.00", actualData.Transactions[1].Postings[3].Amount)
+	assert.Equal(t, "USD", actualData.Transactions[1].Postings[3].Commodity)
 }
 
 func TestBeancountDataReaderReadTransactionPostingLine_AmountExpression(t *testing.T) {
@@ -377,19 +377,19 @@ func TestBeancountDataReaderReadTransactionPostingLine_AmountExpression(t *testi
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
 
-	assert.Equal(t, 1, len(actualData.transactions))
+	assert.Equal(t, 1, len(actualData.Transactions))
 
-	assert.Equal(t, "2024-01-01", actualData.transactions[0].date)
-	assert.Equal(t, 2, len(actualData.transactions[0].postings))
-	assert.Equal(t, "Income:TestCategory", actualData.transactions[0].postings[0].account)
-	assert.Equal(t, "(1.2-3.4) * 5.6 / 7.8", actualData.transactions[0].postings[0].originalAmount)
-	assert.Equal(t, "-1.58", actualData.transactions[0].postings[0].amount)
-	assert.Equal(t, "CNY", actualData.transactions[0].postings[0].commodity)
+	assert.Equal(t, "2024-01-01", actualData.Transactions[0].Date)
+	assert.Equal(t, 2, len(actualData.Transactions[0].Postings))
+	assert.Equal(t, "Income:TestCategory", actualData.Transactions[0].Postings[0].Account)
+	assert.Equal(t, "(1.2-3.4) * 5.6 / 7.8", actualData.Transactions[0].Postings[0].OriginalAmount)
+	assert.Equal(t, "-1.58", actualData.Transactions[0].Postings[0].Amount)
+	assert.Equal(t, "CNY", actualData.Transactions[0].Postings[0].Commodity)
 
-	assert.Equal(t, "Assets:TestAccount", actualData.transactions[0].postings[1].account)
-	assert.Equal(t, "1.2 * 3.4/-5.6 - 7.8", actualData.transactions[0].postings[1].originalAmount)
-	assert.Equal(t, "-8.53", actualData.transactions[0].postings[1].amount)
-	assert.Equal(t, "CNY", actualData.transactions[0].postings[1].commodity)
+	assert.Equal(t, "Assets:TestAccount", actualData.Transactions[0].Postings[1].Account)
+	assert.Equal(t, "1.2 * 3.4/-5.6 - 7.8", actualData.Transactions[0].Postings[1].OriginalAmount)
+	assert.Equal(t, "-8.53", actualData.Transactions[0].Postings[1].Amount)
+	assert.Equal(t, "CNY", actualData.Transactions[0].Postings[1].Commodity)
 }
 
 func TestBeancountDataReaderReadTransactionPostingLine_InvalidAmountExpression(t *testing.T) {
@@ -444,8 +444,8 @@ func TestBeancountDataReaderReadTransactionPostingLine_MissingAmount(t *testing.
 
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
-	assert.Equal(t, 1, len(actualData.transactions))
-	assert.Equal(t, 0, len(actualData.transactions[0].postings))
+	assert.Equal(t, 1, len(actualData.Transactions))
+	assert.Equal(t, 0, len(actualData.Transactions[0].Postings))
 
 	reader, err = createNewBeancountDataReader(context, []byte(""+
 		"2024-01-01 *\n"+
@@ -454,8 +454,8 @@ func TestBeancountDataReaderReadTransactionPostingLine_MissingAmount(t *testing.
 
 	actualData, err = reader.read(context)
 	assert.Nil(t, err)
-	assert.Equal(t, 1, len(actualData.transactions))
-	assert.Equal(t, 0, len(actualData.transactions[0].postings))
+	assert.Equal(t, 1, len(actualData.Transactions))
+	assert.Equal(t, 0, len(actualData.Transactions[0].Postings))
 }
 
 func TestBeancountDataReaderReadTransactionPostingLine_MissingCommodity(t *testing.T) {
@@ -503,18 +503,18 @@ func TestBeancountDataReaderReadTransactionMetadataLine(t *testing.T) {
 	actualData, err := reader.read(context)
 	assert.Nil(t, err)
 
-	assert.Equal(t, 2, len(actualData.transactions))
+	assert.Equal(t, 2, len(actualData.Transactions))
 
-	assert.Equal(t, "2024-01-01", actualData.transactions[0].date)
-	assert.Equal(t, 2, len(actualData.transactions[0].postings))
-	assert.Equal(t, 2, len(actualData.transactions[0].metadata))
-	assert.Equal(t, "value", actualData.transactions[0].metadata["key"])
-	assert.Equal(t, "value 2", actualData.transactions[0].metadata["key2"])
+	assert.Equal(t, "2024-01-01", actualData.Transactions[0].Date)
+	assert.Equal(t, 2, len(actualData.Transactions[0].Postings))
+	assert.Equal(t, 2, len(actualData.Transactions[0].Metadata))
+	assert.Equal(t, "value", actualData.Transactions[0].Metadata["key"])
+	assert.Equal(t, "value 2", actualData.Transactions[0].Metadata["key2"])
 
-	assert.Equal(t, "2024-01-02", actualData.transactions[1].date)
-	assert.Equal(t, 2, len(actualData.transactions[1].postings))
-	assert.Equal(t, 2, len(actualData.transactions[1].postings[0].metadata))
-	assert.Equal(t, "value6", actualData.transactions[1].postings[0].metadata["key6"])
-	assert.Equal(t, "value 7", actualData.transactions[1].postings[0].metadata["key7"])
-	assert.Equal(t, 0, len(actualData.transactions[1].postings[1].metadata))
+	assert.Equal(t, "2024-01-02", actualData.Transactions[1].Date)
+	assert.Equal(t, 2, len(actualData.Transactions[1].Postings))
+	assert.Equal(t, 2, len(actualData.Transactions[1].Postings[0].Metadata))
+	assert.Equal(t, "value6", actualData.Transactions[1].Postings[0].Metadata["key6"])
+	assert.Equal(t, "value 7", actualData.Transactions[1].Postings[0].Metadata["key7"])
+	assert.Equal(t, 0, len(actualData.Transactions[1].Postings[1].Metadata))
 }

pkg/converters/beancount/beancount_data_test.go

@@ -8,34 +8,34 @@ import (
 
 func TestBeancountAccount_IsOpeningBalanceEquityAccount_True(t *testing.T) {
 	account := beancountAccount{
-		accountType: beancountEquityAccountType,
-		name:        "Equity:Opening-Balances",
+		AccountType: beancountEquityAccountType,
+		Name:        "Equity:Opening-Balances",
 	}
 	assert.True(t, account.isOpeningBalanceEquityAccount())
 
 	account = beancountAccount{
-		accountType: beancountEquityAccountType,
-		name:        "E:Opening-Balances",
+		AccountType: beancountEquityAccountType,
+		Name:        "E:Opening-Balances",
 	}
 	assert.True(t, account.isOpeningBalanceEquityAccount())
 }
 
 func TestBeancountAccount_IsOpeningBalanceEquityAccount_False(t *testing.T) {
 	account := beancountAccount{
-		accountType: beancountAssetsAccountType,
-		name:        "Equity:Opening-Balances",
+		AccountType: beancountAssetsAccountType,
+		Name:        "Equity:Opening-Balances",
 	}
 	assert.False(t, account.isOpeningBalanceEquityAccount())
 
 	account = beancountAccount{
-		accountType: beancountEquityAccountType,
-		name:        "Opening-Balances",
+		AccountType: beancountEquityAccountType,
+		Name:        "Opening-Balances",
 	}
 	assert.False(t, account.isOpeningBalanceEquityAccount())
 
 	account = beancountAccount{
-		accountType: beancountEquityAccountType,
-		name:        "Equity:Other",
+		AccountType: beancountEquityAccountType,
+		Name:        "Equity:Other",
 	}
 	assert.False(t, account.isOpeningBalanceEquityAccount())
 }

pkg/converters/beancount/beancount_transaction_data_table.go

@@ -110,49 +110,49 @@ func (t *beancountTransactionDataRowIterator) Next(ctx core.Context, user *model
 func (t *beancountTransactionDataRowIterator) parseTransaction(ctx core.Context, user *models.User, beancountEntry *beancountTransactionEntry) (map[datatable.TransactionDataTableColumn]string, error) {
 	data := make(map[datatable.TransactionDataTableColumn]string, len(beancountTransactionSupportedColumns))
 
-	if beancountEntry.date == "" {
+	if beancountEntry.Date == "" {
 		return nil, errs.ErrMissingTransactionTime
 	}
 
 	// Beancount supports the international ISO 8601 standard format for dates, with dashes or the same ordering with slashes
-	data[datatable.TRANSACTION_DATA_TABLE_TRANSACTION_TIME] = strings.ReplaceAll(beancountEntry.date, "/", "-") + " 00:00:00"
+	data[datatable.TRANSACTION_DATA_TABLE_TRANSACTION_TIME] = strings.ReplaceAll(beancountEntry.Date, "/", "-") + " 00:00:00"
 
-	if len(beancountEntry.postings) == 2 {
-		splitData1 := beancountEntry.postings[0]
-		splitData2 := beancountEntry.postings[1]
+	if len(beancountEntry.Postings) == 2 {
+		splitData1 := beancountEntry.Postings[0]
+		splitData2 := beancountEntry.Postings[1]
 
-		account1 := t.dataTable.accountMap[splitData1.account]
-		account2 := t.dataTable.accountMap[splitData2.account]
+		account1 := t.dataTable.accountMap[splitData1.Account]
+		account2 := t.dataTable.accountMap[splitData2.Account]
 
 		if account1 == nil || account2 == nil {
 			return nil, errs.ErrMissingAccountData
 		}
 
-		amount1, err := utils.ParseAmount(splitData1.amount)
+		amount1, err := utils.ParseAmount(splitData1.Amount)
 
 		if err != nil {
-			log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse amount \"%s\", because %s", splitData1.amount, err.Error())
+			log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse amount \"%s\", because %s", splitData1.Amount, err.Error())
 			return nil, errs.ErrAmountInvalid
 		}
 
-		amount2, err := utils.ParseAmount(splitData2.amount)
+		amount2, err := utils.ParseAmount(splitData2.Amount)
 
 		if err != nil {
-			log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse amount \"%s\", because %s", splitData2.amount, err.Error())
+			log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse amount \"%s\", because %s", splitData2.Amount, err.Error())
 			return nil, errs.ErrAmountInvalid
 		}
 
-		if ((account1.accountType == beancountEquityAccountType || account1.accountType == beancountIncomeAccountType) && (account2.accountType == beancountAssetsAccountType || account2.accountType == beancountLiabilitiesAccountType)) ||
-			((account2.accountType == beancountEquityAccountType || account2.accountType == beancountIncomeAccountType) && (account1.accountType == beancountAssetsAccountType || account1.accountType == beancountLiabilitiesAccountType)) { // income
+		if ((account1.AccountType == beancountEquityAccountType || account1.AccountType == beancountIncomeAccountType) && (account2.AccountType == beancountAssetsAccountType || account2.AccountType == beancountLiabilitiesAccountType)) ||
+			((account2.AccountType == beancountEquityAccountType || account2.AccountType == beancountIncomeAccountType) && (account1.AccountType == beancountAssetsAccountType || account1.AccountType == beancountLiabilitiesAccountType)) { // income
 			fromAccount := account1
 			toAccount := account2
-			toCurrency := splitData2.commodity
+			toCurrency := splitData2.Commodity
 			toAmount := amount2
 
-			if (account2.accountType == beancountEquityAccountType || account2.accountType == beancountIncomeAccountType) && (account1.accountType == beancountAssetsAccountType || account1.accountType == beancountLiabilitiesAccountType) {
+			if (account2.AccountType == beancountEquityAccountType || account2.AccountType == beancountIncomeAccountType) && (account1.AccountType == beancountAssetsAccountType || account1.AccountType == beancountLiabilitiesAccountType) {
 				fromAccount = account2
 				toAccount = account1
-				toCurrency = splitData1.commodity
+				toCurrency = splitData1.Commodity
 				toAmount = amount1
 			}
 
@@ -162,48 +162,48 @@ func (t *beancountTransactionDataRowIterator) parseTransaction(ctx core.Context,
 				data[datatable.TRANSACTION_DATA_TABLE_TRANSACTION_TYPE] = utils.IntToString(int(models.TRANSACTION_TYPE_INCOME))
 			}
 
-			data[datatable.TRANSACTION_DATA_TABLE_SUB_CATEGORY] = fromAccount.name
-			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_NAME] = toAccount.name
+			data[datatable.TRANSACTION_DATA_TABLE_SUB_CATEGORY] = fromAccount.Name
+			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_NAME] = toAccount.Name
 			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_CURRENCY] = toCurrency
 			data[datatable.TRANSACTION_DATA_TABLE_AMOUNT] = utils.FormatAmount(toAmount)
-		} else if account1.accountType == beancountExpensesAccountType && (account2.accountType == beancountAssetsAccountType || account2.accountType == beancountLiabilitiesAccountType) ||
-			(account2.accountType == beancountExpensesAccountType && (account1.accountType == beancountAssetsAccountType || account1.accountType == beancountLiabilitiesAccountType)) { // expense
+		} else if account1.AccountType == beancountExpensesAccountType && (account2.AccountType == beancountAssetsAccountType || account2.AccountType == beancountLiabilitiesAccountType) ||
+			(account2.AccountType == beancountExpensesAccountType && (account1.AccountType == beancountAssetsAccountType || account1.AccountType == beancountLiabilitiesAccountType)) { // expense
 			fromAccount := account1
-			fromCurrency := splitData1.commodity
+			fromCurrency := splitData1.Commodity
 			fromAmount := amount1
 			toAccount := account2
 
-			if account1.accountType == beancountExpensesAccountType && (account2.accountType == beancountAssetsAccountType || account2.accountType == beancountLiabilitiesAccountType) {
+			if account1.AccountType == beancountExpensesAccountType && (account2.AccountType == beancountAssetsAccountType || account2.AccountType == beancountLiabilitiesAccountType) {
 				fromAccount = account2
-				fromCurrency = splitData2.commodity
+				fromCurrency = splitData2.Commodity
 				fromAmount = amount2
 				toAccount = account1
 			}
 
 			data[datatable.TRANSACTION_DATA_TABLE_TRANSACTION_TYPE] = utils.IntToString(int(models.TRANSACTION_TYPE_EXPENSE))
-			data[datatable.TRANSACTION_DATA_TABLE_SUB_CATEGORY] = toAccount.name
-			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_NAME] = fromAccount.name
+			data[datatable.TRANSACTION_DATA_TABLE_SUB_CATEGORY] = toAccount.Name
+			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_NAME] = fromAccount.Name
 			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_CURRENCY] = fromCurrency
 			data[datatable.TRANSACTION_DATA_TABLE_AMOUNT] = utils.FormatAmount(-fromAmount)
-		} else if (account1.accountType == beancountAssetsAccountType || account1.accountType == beancountLiabilitiesAccountType) &&
-			(account2.accountType == beancountAssetsAccountType || account2.accountType == beancountLiabilitiesAccountType) {
+		} else if (account1.AccountType == beancountAssetsAccountType || account1.AccountType == beancountLiabilitiesAccountType) &&
+			(account2.AccountType == beancountAssetsAccountType || account2.AccountType == beancountLiabilitiesAccountType) {
 			var fromAccount, toAccount *beancountAccount
 			var fromAmount, toAmount int64
 			var fromCurrency, toCurrency string
 
 			if amount1 < 0 {
 				fromAccount = account1
-				fromCurrency = splitData1.commodity
+				fromCurrency = splitData1.Commodity
 				fromAmount = -amount1
 				toAccount = account2
-				toCurrency = splitData2.commodity
+				toCurrency = splitData2.Commodity
 				toAmount = amount2
 			} else if amount2 < 0 {
 				fromAccount = account2
-				fromCurrency = splitData2.commodity
+				fromCurrency = splitData2.Commodity
 				fromAmount = -amount2
 				toAccount = account1
-				toCurrency = splitData1.commodity
+				toCurrency = splitData1.Commodity
 				toAmount = amount1
 			} else {
 				log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse transfer transaction, because unexcepted account amounts \"%d\" and \"%d\"", amount1, amount2)
@@ -212,26 +212,26 @@ func (t *beancountTransactionDataRowIterator) parseTransaction(ctx core.Context,
 
 			data[datatable.TRANSACTION_DATA_TABLE_TRANSACTION_TYPE] = utils.IntToString(int(models.TRANSACTION_TYPE_TRANSFER))
 			data[datatable.TRANSACTION_DATA_TABLE_SUB_CATEGORY] = ""
-			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_NAME] = fromAccount.name
+			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_NAME] = fromAccount.Name
 			data[datatable.TRANSACTION_DATA_TABLE_ACCOUNT_CURRENCY] = fromCurrency
 			data[datatable.TRANSACTION_DATA_TABLE_AMOUNT] = utils.FormatAmount(fromAmount)
-			data[datatable.TRANSACTION_DATA_TABLE_RELATED_ACCOUNT_NAME] = toAccount.name
+			data[datatable.TRANSACTION_DATA_TABLE_RELATED_ACCOUNT_NAME] = toAccount.Name
 			data[datatable.TRANSACTION_DATA_TABLE_RELATED_ACCOUNT_CURRENCY] = toCurrency
 			data[datatable.TRANSACTION_DATA_TABLE_RELATED_AMOUNT] = utils.FormatAmount(toAmount)
 		} else {
-			log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse transaction, because unexcepted account types \"%d\" and \"%d\"", account1.accountType, account2.accountType)
+			log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse transaction, because unexcepted account types \"%d\" and \"%d\"", account1.AccountType, account2.AccountType)
 			return nil, errs.ErrThereAreNotSupportedTransactionType
 		}
-	} else if len(beancountEntry.postings) <= 1 {
-		log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse transaction, because postings count is %d", len(beancountEntry.postings))
+	} else if len(beancountEntry.Postings) <= 1 {
+		log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse transaction, because postings count is %d", len(beancountEntry.Postings))
 		return nil, errs.ErrInvalidBeancountFile
 	} else {
-		log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse split transaction, because postings count is %d", len(beancountEntry.postings))
+		log.Errorf(ctx, "[beancount_transaction_data_table.parseTransaction] cannot parse split transaction, because postings count is %d", len(beancountEntry.Postings))
 		return nil, errs.ErrNotSupportedSplitTransactions
 	}
 
-	data[datatable.TRANSACTION_DATA_TABLE_TAGS] = strings.Join(beancountEntry.tags, BEANCOUNT_TRANSACTION_TAG_SEPARATOR)
-	data[datatable.TRANSACTION_DATA_TABLE_DESCRIPTION] = beancountEntry.narration
+	data[datatable.TRANSACTION_DATA_TABLE_TAGS] = strings.Join(beancountEntry.Tags, BEANCOUNT_TRANSACTION_TAG_SEPARATOR)
+	data[datatable.TRANSACTION_DATA_TABLE_DESCRIPTION] = beancountEntry.Narration
 
 	return data, nil
 }
@@ -242,7 +242,7 @@ func createNewBeancountTransactionDataTable(beancountData *beancountData) (*bean
 	}
 
 	return &beancountTransactionDataTable{
-		allData:    beancountData.transactions,
-		accountMap: beancountData.accounts,
+		allData:    beancountData.Transactions,
+		accountMap: beancountData.Accounts,
 	}, nil
 }