Transaction History Store

BankAccount/pkg/store/transactionhistory.go

@@ -1 +1,79 @@
 package store
+
+import (
+	"bankacc/pkg/entities"
+	"database/sql"
+	"time"
+)
+
+type TransactionHistoryStore interface {
+	Insert(userId int, accountId int, amount float64, action string) (*entities.TransactionHistory, error)
+	GetTransactionsById(id int) ([]*entities.TransactionHistory, error)
+	GetTransactionsByIdFromToDate(id int, fromDate time.Time, toDate time.Time) ([]*entities.TransactionHistory, error)
+}
+
+type TransactionHistoryModel struct {
+	Db *sql.DB
+}
+
+func NewTransactionHistoryStoreModel(db *sql.DB) *TransactionHistoryModel {
+	return &TransactionHistoryModel{
+		Db: db,
+	}
+}
+
+func (store *TransactionHistoryModel) Insert(userId int, accountId int, amount float64, action string) (*entities.TransactionHistory, error) {
+	now := time.Now()
+
+	result, err := store.Db.Exec("INSERT INTO TransactionHistory(user_id, account_id, amount, action, created_at) VALUES(?, ?, ?, ?, ?)", userId, accountId, amount, action, now)
+	if err != nil {
+		return nil, err
+	}
+	res, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+	transaction := entities.TransactionHistory{
+		Id:        int(res),
+		UserId:    userId,
+		AccountId: accountId,
+		Amount:    amount,
+		Action:    action,
+		CreatedAt: now,
+	}
+	return &transaction, nil
+}
+
+func (store *TransactionHistoryModel) GetTransactionsById(id int) ([]*entities.TransactionHistory, error) {
+	var transactions []*entities.TransactionHistory
+	result, err := store.Db.Query("SELECT * FROM TransactionHistory WHERE user_id = ?", id)
+	if err != nil {
+		return nil, err
+	}
+	var transaction entities.TransactionHistory
+	for result.Next() {
+		err := result.Scan(&transaction.Id, &transaction.UserId, &transaction.AccountId, &transaction.Amount, &transaction.Action, &transaction.CreatedAt)
+		if err != nil {
+			return nil, err
+		}
+		transactions = append(transactions, &transaction)
+	}
+	return transactions, nil
+}
+
+func (store *TransactionHistoryModel) GetTransactionsByIdFromToDate(id int, fromDate time.Time, toDate time.Time) ([]*entities.TransactionHistory, error) {
+	var transactions []*entities.TransactionHistory
+	result, err := store.Db.Query("SELECT * FROM TransactionHistory WHERE user_id = ? and created_at BETWEEN ? and ?", id, fromDate, toDate)
+	if err != nil {
+		return nil, err
+	}
+	var transaction entities.TransactionHistory
+	for result.Next() {
+		err := result.Scan(&transaction.Id, &transaction.UserId, &transaction.AccountId, &transaction.Amount, &transaction.Action, &transaction.CreatedAt)
+		if err != nil {
+			return nil, err
+		}
+		transactions = append(transactions, &transaction)
+	}
+	return transactions, nil
+}

BankAccount/pkg/tests/transactionhistorystore_test.go

@@ -0,0 +1,150 @@
+package tests
+
+import (
+	"bankacc/pkg/entities"
+	"bankacc/pkg/store"
+	"database/sql"
+	"log"
+	"testing"
+	"time"
+
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/stretchr/testify/suite"
+)
+
+func MySQLInit() *sql.DB {
+	dbDriver := "mysql"
+	dbUser := "root"
+	dbPass := "Password1!"
+	dbName := "BankAccount?parseTime=true"
+	db, err := sql.Open(dbDriver, dbUser+":"+dbPass+"@/"+dbName)
+	if err != nil {
+		log.Println(err)
+	}
+	return db
+}
+
+type TearDownTestSuite interface {
+	TearDownTest()
+}
+
+type TransactionHistoryTestSuite struct {
+	suite.Suite
+	Transaction      *entities.TransactionHistory
+	Transactions     []entities.TransactionHistory
+	TransactionsP    []*entities.TransactionHistory
+	TransactionStore store.TransactionHistoryModel
+	Db               *sql.DB
+}
+
+func (suite *TransactionHistoryTestSuite) SetupTest() {
+	var err error
+	suite.Db = MySQLInit()
+	transaction := store.NewTransactionHistoryStoreModel(suite.Db)
+	suite.Transactions = []entities.TransactionHistory{
+		{
+			UserId:    1,
+			AccountId: 1,
+			Amount:    100,
+			Action:    "Deposit",
+		},
+		{
+			UserId:    1,
+			AccountId: 1,
+			Amount:    100,
+			Action:    "Withdraw",
+		},
+		{
+			UserId:    1,
+			AccountId: 2,
+			Amount:    44,
+			Action:    "Deposit",
+		},
+		{
+			UserId:    2,
+			AccountId: 1,
+			Amount:    200,
+			Action:    "Withdraw",
+		},
+		{
+			UserId:    3,
+			AccountId: 3,
+			Amount:    300,
+			Action:    "Deposit",
+		},
+	}
+
+	for _, value := range suite.Transactions {
+		suite.Transaction, err = transaction.Insert(value.UserId, value.AccountId, value.Amount, value.Action)
+		if err != nil {
+			suite.T().Fatal("Unable to run InsertTransactionHistory store func")
+		}
+		suite.TransactionsP = append(suite.TransactionsP, suite.Transaction)
+	}
+}
+
+func (suite *TransactionHistoryTestSuite) TestGetTransactionById() {
+	store := store.NewTransactionHistoryStoreModel(suite.Db)
+	var err error
+	var transact []*entities.TransactionHistory
+	for _, value := range suite.TransactionsP {
+		transact, err = store.GetTransactionsById(value.UserId)
+		if err != nil {
+			suite.T().Fatal("Unable to run GetTransactionsById store func")
+		}
+	}
+
+	for _, value := range suite.TransactionsP {
+		for i := range transact {
+			if value.Id == transact[i].Id {
+				suite.Equal(value.UserId, transact[i].UserId)
+				suite.Equal(value.AccountId, transact[i].AccountId)
+				suite.Equal(value.Action, transact[i].Action)
+				suite.Equal(value.Amount, transact[i].Amount)
+			}
+		}
+	}
+}
+
+func (suite *TransactionHistoryTestSuite) TestGetTransactionByIdFromToDate() {
+	store := store.NewTransactionHistoryStoreModel(suite.Db)
+	var err error
+	var transact []*entities.TransactionHistory
+	for _, value := range suite.TransactionsP {
+		var k int
+		for k = value.CreatedAt.Nanosecond(); k >= 10; k = k / 10 {
+		}
+		if k >= 5 {
+			value.CreatedAt = value.CreatedAt.Add(time.Second * 1)
+		}
+		value.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", value.CreatedAt.UTC().Format("2006-01-02 15:04:05"))
+		transact, err = store.GetTransactionsByIdFromToDate(value.UserId, value.CreatedAt.UTC(), value.CreatedAt.UTC())
+		if err != nil {
+			suite.T().Fatal("Unable to run GetTransactionsByIdFromDate store func")
+		}
+	}
+
+	for _, value := range suite.TransactionsP {
+		for i := range transact {
+			if value.Id == transact[i].Id {
+				suite.Equal(value.UserId, transact[i].UserId)
+				suite.Equal(value.AccountId, transact[i].AccountId)
+				suite.Equal(value.Action, transact[i].Action)
+				suite.Equal(value.Amount, transact[i].Amount)
+			}
+		}
+	}
+}
+
+func TestTransactionHistoryTestSuite(t *testing.T) {
+	suite.Run(t, new(TransactionHistoryTestSuite))
+}
+
+func (suite *TransactionHistoryTestSuite) TearDownTest() {
+	for i := 0; i < len(suite.TransactionsP); i++ {
+		_, err := suite.Db.Exec("DELETE FROM TransactionHistory WHERE id=?", suite.TransactionsP[i].Id)
+		if err != nil {
+			suite.T().Fatal("Unable to run delete query")
+		}
+	}
+}