code refactor

pkg/converters/data_table_transaction_data_converter.go

@@ -38,17 +38,17 @@ const (
 // DataTableTransactionDataExporter defines the structure of plain text data table exporter for transaction data
 type DataTableTransactionDataExporter struct {
 	dataColumnMapping       map[DataTableColumn]string
-	transactionTypeMapping  map[models.TransactionDbType]string
+	transactionTypeMapping  map[models.TransactionType]string
 	geoLocationSeparator    string
 	transactionTagSeparator string
 }
 
 // DataTableTransactionDataImporter defines the structure of plain text data table importer for transaction data
 type DataTableTransactionDataImporter struct {
-	dataColumnMapping          map[DataTableColumn]string
+	dataColumnMapping       map[DataTableColumn]string
-	transactionTypeNameMapping map[string]models.TransactionDbType
+	transactionTypeMapping  map[models.TransactionType]string
-	geoLocationSeparator       string
+	geoLocationSeparator    string
-	transactionTagSeparator    string
+	transactionTagSeparator string
 }
 
 func (c *DataTableTransactionDataExporter) buildExportedContent(ctx core.Context, dataTableBuilder DataTableBuilder, uid int64, transactions []*models.Transaction, accountMap map[int64]*models.Account, categoryMap map[int64]*models.TransactionCategory, tagMap map[int64]*models.TransactionTag, allTagIndexes map[int64][]int64) error {
@@ -88,7 +88,13 @@ func (c *DataTableTransactionDataExporter) buildExportedContent(ctx core.Context
 }
 
 func (c *DataTableTransactionDataExporter) getDisplayTransactionTypeName(transactionDbType models.TransactionDbType) string {
-	transactionTypeName, exists := c.transactionTypeMapping[transactionDbType]
+	transactionType, err := transactionDbType.ToTransactionType()
+
+	if err != nil {
+		return ""
+	}
+
+	transactionTypeName, exists := c.transactionTypeMapping[transactionType]
 
 	if !exists {
 		return ""
@@ -188,6 +194,12 @@ func (c *DataTableTransactionDataImporter) parseImportedData(ctx core.Context, u
 		return nil, nil, nil, nil, errs.ErrNotFoundTransactionDataInFile
 	}
 
+	nameDbTypeMap, err := c.buildTransactionTypeNameDbTypeMap()
+
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
 	headerLineItems := dataTable.HeaderLineColumnNames()
 	headerItemMap := make(map[string]int)
 
@@ -269,7 +281,7 @@ func (c *DataTableTransactionDataImporter) parseImportedData(ctx core.Context, u
 			return nil, nil, nil, nil, errs.ErrTransactionTimeInvalid
 		}
 
-		transactionDbType, err := c.getTransactionDbType(dataRow.GetData(typeColumnIdx))
+		transactionDbType, err := c.getTransactionDbType(nameDbTypeMap, dataRow.GetData(typeColumnIdx))
 
 		if err != nil {
 			log.Errorf(ctx, "[data_table_transaction_data_converter.parseImportedData] cannot parse transaction type \"%s\" in data row \"index:%d\" for user \"uid:%d\", because %s", dataRow.GetData(typeColumnIdx), dataRowIndex, user.Uid, err.Error())
@@ -488,8 +500,22 @@ func (c *DataTableTransactionDataImporter) parseImportedData(ctx core.Context, u
 	return allNewTransactions, allNewAccounts, allNewSubCategories, allNewTags, nil
 }
 
-func (c *DataTableTransactionDataImporter) getTransactionDbType(transactionTypeName string) (models.TransactionDbType, error) {
+func (c *DataTableTransactionDataImporter) buildTransactionTypeNameDbTypeMap() (map[string]models.TransactionDbType, error) {
-	transactionType, exists := c.transactionTypeNameMapping[transactionTypeName]
+	if c.transactionTypeMapping == nil {
+		return nil, errs.ErrTransactionTypeInvalid
+	}
+
+	nameDbTypeMap := make(map[string]models.TransactionDbType, len(c.transactionTypeMapping))
+	nameDbTypeMap[c.transactionTypeMapping[models.TRANSACTION_TYPE_MODIFY_BALANCE]] = models.TRANSACTION_DB_TYPE_MODIFY_BALANCE
+	nameDbTypeMap[c.transactionTypeMapping[models.TRANSACTION_TYPE_INCOME]] = models.TRANSACTION_DB_TYPE_INCOME
+	nameDbTypeMap[c.transactionTypeMapping[models.TRANSACTION_TYPE_EXPENSE]] = models.TRANSACTION_DB_TYPE_EXPENSE
+	nameDbTypeMap[c.transactionTypeMapping[models.TRANSACTION_TYPE_TRANSFER]] = models.TRANSACTION_DB_TYPE_TRANSFER_OUT
+
+	return nameDbTypeMap, nil
+}
+
+func (c *DataTableTransactionDataImporter) getTransactionDbType(nameDbTypeMap map[string]models.TransactionDbType, transactionTypeName string) (models.TransactionDbType, error) {
+	transactionType, exists := nameDbTypeMap[transactionTypeName]
 
 	if !exists {
 		return 0, errs.ErrTransactionTypeInvalid

pkg/converters/ezbookkeeping_transaction_data_csv_file_converter.go

@@ -22,10 +22,10 @@ var (
 		},
 		ezBookKeepingTransactionDataPlainTextImporter{
 			DataTableTransactionDataImporter: DataTableTransactionDataImporter{
-				dataColumnMapping:          ezbookkeepingDataColumnNameMapping,
+				dataColumnMapping:       ezbookkeepingDataColumnNameMapping,
-				transactionTypeNameMapping: ezbookkeepingNameTransactionTypeMapping,
+				transactionTypeMapping:  ezbookkeepingTransactionTypeNameMapping,
-				geoLocationSeparator:       " ",
+				geoLocationSeparator:    " ",
-				transactionTagSeparator:    ";",
+				transactionTagSeparator: ";",
 			},
 			columnSeparator: ",",
 			lineSeparator:   "\n",

pkg/converters/ezbookkeeping_transaction_data_plain_text_converter.go

@@ -37,19 +37,11 @@ var ezbookkeepingDataColumnNameMapping = map[DataTableColumn]string{
 	DATA_TABLE_DESCRIPTION:              "Description",
 }
 
-var ezbookkeepingTransactionTypeNameMapping = map[models.TransactionDbType]string{
+var ezbookkeepingTransactionTypeNameMapping = map[models.TransactionType]string{
-	models.TRANSACTION_DB_TYPE_MODIFY_BALANCE: "Balance Modification",
+	models.TRANSACTION_TYPE_MODIFY_BALANCE: "Balance Modification",
-	models.TRANSACTION_DB_TYPE_INCOME:         "Income",
+	models.TRANSACTION_TYPE_INCOME:         "Income",
-	models.TRANSACTION_DB_TYPE_EXPENSE:        "Expense",
+	models.TRANSACTION_TYPE_EXPENSE:        "Expense",
-	models.TRANSACTION_DB_TYPE_TRANSFER_OUT:   "Transfer",
+	models.TRANSACTION_TYPE_TRANSFER:       "Transfer",
-	models.TRANSACTION_DB_TYPE_TRANSFER_IN:    "Transfer",
-}
-
-var ezbookkeepingNameTransactionTypeMapping = map[string]models.TransactionDbType{
-	"Balance Modification": models.TRANSACTION_DB_TYPE_MODIFY_BALANCE,
-	"Income":               models.TRANSACTION_DB_TYPE_INCOME,
-	"Expense":              models.TRANSACTION_DB_TYPE_EXPENSE,
-	"Transfer":             models.TRANSACTION_DB_TYPE_TRANSFER_OUT,
 }
 
 var ezbookkeepingDataColumns = []DataTableColumn{

pkg/converters/ezbookkeeping_transaction_data_tsv_file_converter.go

@@ -22,10 +22,10 @@ var (
 		},
 		ezBookKeepingTransactionDataPlainTextImporter{
 			DataTableTransactionDataImporter: DataTableTransactionDataImporter{
-				dataColumnMapping:          ezbookkeepingDataColumnNameMapping,
+				dataColumnMapping:       ezbookkeepingDataColumnNameMapping,
-				transactionTypeNameMapping: ezbookkeepingNameTransactionTypeMapping,
+				transactionTypeMapping:  ezbookkeepingTransactionTypeNameMapping,
-				geoLocationSeparator:       " ",
+				geoLocationSeparator:    " ",
-				transactionTagSeparator:    ";",
+				transactionTagSeparator: ";",
 			},
 			columnSeparator: "\t",
 			lineSeparator:   "\n",

pkg/models/imported_transaction.go

@@ -43,19 +43,9 @@ type ImportTransactionResponsePageWrapper struct {
 
 // ToImportTransactionResponse returns the a view-objects according to imported transaction data
 func (t ImportTransaction) ToImportTransactionResponse() *ImportTransactionResponse {
-	var transactionType TransactionType
+	transactionType, err := t.Type.ToTransactionType()
 
-	if t.Type == TRANSACTION_DB_TYPE_MODIFY_BALANCE {
+	if err != nil {
-		transactionType = TRANSACTION_TYPE_MODIFY_BALANCE
-	} else if t.Type == TRANSACTION_DB_TYPE_EXPENSE {
-		transactionType = TRANSACTION_TYPE_EXPENSE
-	} else if t.Type == TRANSACTION_DB_TYPE_INCOME {
-		transactionType = TRANSACTION_TYPE_INCOME
-	} else if t.Type == TRANSACTION_DB_TYPE_TRANSFER_OUT {
-		transactionType = TRANSACTION_TYPE_TRANSFER
-	} else if t.Type == TRANSACTION_DB_TYPE_TRANSFER_IN {
-		transactionType = TRANSACTION_TYPE_TRANSFER
-	} else {
 		return nil
 	}
 

pkg/models/transaction.go

@@ -49,6 +49,23 @@ func (s TransactionDbType) String() string {
 	}
 }
 
+// ToTransactionType returns the transaction type for this db enum
+func (s TransactionDbType) ToTransactionType() (TransactionType, error) {
+	if s == TRANSACTION_DB_TYPE_MODIFY_BALANCE {
+		return TRANSACTION_TYPE_MODIFY_BALANCE, nil
+	} else if s == TRANSACTION_DB_TYPE_EXPENSE {
+		return TRANSACTION_TYPE_EXPENSE, nil
+	} else if s == TRANSACTION_DB_TYPE_INCOME {
+		return TRANSACTION_TYPE_INCOME, nil
+	} else if s == TRANSACTION_DB_TYPE_TRANSFER_OUT {
+		return TRANSACTION_TYPE_TRANSFER, nil
+	} else if s == TRANSACTION_DB_TYPE_TRANSFER_IN {
+		return TRANSACTION_TYPE_TRANSFER, nil
+	} else {
+		return 0, errs.ErrTransactionTypeInvalid
+	}
+}
+
 // Transaction represents transaction data stored in database
 type Transaction struct {
 	TransactionId        int64             `xorm:"PK"`
@@ -325,19 +342,9 @@ func (t *Transaction) IsEditable(currentUser *User, utcOffset int16, account *Ac
 
 // ToTransactionInfoResponse returns a view-object according to database model
 func (t *Transaction) ToTransactionInfoResponse(tagIds []int64, editable bool) *TransactionInfoResponse {
-	var transactionType TransactionType
+	transactionType, err := t.Type.ToTransactionType()
 
-	if t.Type == TRANSACTION_DB_TYPE_MODIFY_BALANCE {
+	if err != nil {
-		transactionType = TRANSACTION_TYPE_MODIFY_BALANCE
-	} else if t.Type == TRANSACTION_DB_TYPE_EXPENSE {
-		transactionType = TRANSACTION_TYPE_EXPENSE
-	} else if t.Type == TRANSACTION_DB_TYPE_INCOME {
-		transactionType = TRANSACTION_TYPE_INCOME
-	} else if t.Type == TRANSACTION_DB_TYPE_TRANSFER_OUT {
-		transactionType = TRANSACTION_TYPE_TRANSFER
-	} else if t.Type == TRANSACTION_DB_TYPE_TRANSFER_IN {
-		transactionType = TRANSACTION_TYPE_TRANSFER
-	} else {
 		return nil
 	}