feature: account transfers (#24) (#26)

This closes #21 and allows customers (and owners) to transfer money
between their own accounts freely.

Author: marcellodotgg

internal/api/handler/customer_handler.go

@@ -3,30 +3,36 @@ package handler
 import (
 	"fmt"
 	"net/http"
+	"strconv"
 	"strings"
 
 	"github.com/bytebury/fun-banking/internal/domain"
+	"github.com/bytebury/fun-banking/internal/infrastructure/persistence"
 	"github.com/bytebury/fun-banking/internal/service"
 	"github.com/gin-gonic/gin"
 )
 
 type customerHandler struct {
 	pageObject
-	bankService     service.BankService
-	customerService service.CustomerService
-	accountService  service.AccountService
-	userService     service.UserService
-	Bank            domain.Bank
-	Customer        domain.Customer
+	bankService            service.BankService
+	customerService        service.CustomerService
+	accountService         service.AccountService
+	transactionService     service.TransactionService
+	userService            service.UserService
+	Bank                   domain.Bank
+	Customer               domain.Customer
+	MAX_TRANSACTION_AMOUNT int
 }
 
 func NewCustomerHandler() customerHandler {
 	return customerHandler{
-		bankService:     service.NewBankService(),
-		customerService: service.NewCustomerService(),
-		userService:     service.NewUserService(),
-		accountService:  service.NewAccountService(),
-		Bank:            domain.Bank{},
+		bankService:            service.NewBankService(),
+		customerService:        service.NewCustomerService(),
+		userService:            service.NewUserService(),
+		accountService:         service.NewAccountService(),
+		transactionService:     service.NewTransactionService(),
+		Bank:                   domain.Bank{},
+		MAX_TRANSACTION_AMOUNT: domain.MAX_TRANSACTION_AMOUNT,
 	}
 }
 
@@ -165,6 +171,76 @@ func (h customerHandler) OpenAccount(c *gin.Context) {
 	c.Header("HX-Redirect", fmt.Sprintf("/accounts/%d", account.ID))
 }
 
+func (h customerHandler) OpenTransferMoneyModal(c *gin.Context) {
+	h.Reset(c)
+	h.ModalType = "transfer_money_modal"
+
+	if err := h.customerService.FindByID(c.Param("id"), &h.Customer); err != nil {
+		c.HTML(http.StatusNotFound, "not-found", nil)
+		return
+	}
+
+	c.HTML(http.StatusOK, "modal", h)
+}
+
+func (h customerHandler) TransferMoney(c *gin.Context) {
+	h.Reset(c)
+
+	if err := h.customerService.FindByID(c.Param("id"), &h.Customer); err != nil {
+		h.Form.Errors["general"] = "Could not find customer"
+		c.HTML(http.StatusNotFound, "account/transfer-money-form", h)
+		return
+	}
+
+	var fromAccount domain.Account
+	var toAccount domain.Account
+
+	if err := persistence.DB.First(&fromAccount, "id = ?", h.Form.Data["from_account"]).Error; err != nil {
+		h.Form.Errors["general"] = "Account does not exist"
+		c.HTML(http.StatusNotFound, "account/transfer-money-form", h)
+		return
+	}
+
+	if err := persistence.DB.First(&toAccount, "id = ?", h.Form.Data["to_account"]).Error; err != nil {
+		h.Form.Errors["general"] = "Account does not exist"
+		c.HTML(http.StatusNotFound, "account/transfer_money_form", h)
+		return
+	}
+
+	amount, err := strconv.ParseFloat(h.Form.Data["amount"], 64)
+
+	if err != nil {
+		h.Form.Errors["amount"] = "Invalid currency value"
+		c.HTML(http.StatusUnprocessableEntity, "account/transfer_money_form", h)
+	}
+
+	if err := h.transactionService.TransferMoney(fromAccount, toAccount, amount); err != nil {
+		switch err := err.Error(); err {
+		case "not enough money":
+			h.Form.Errors["from_account"] = "You do not have enough money in this account"
+			c.HTML(http.StatusUnprocessableEntity, "account/transfer_money_form", h)
+			return
+		case "cannot transfer to same account":
+			h.Form.Errors["to_account"] = "You cannot transfer money to the same account"
+			c.HTML(http.StatusUnprocessableEntity, "account/transfer_money_form", h)
+			return
+		case "cannot transfer to other customers accounts":
+			h.Form.Errors["general"] = "You do not have enough money in this account"
+			c.HTML(http.StatusUnprocessableEntity, "account/transfer_money_form", h)
+			return
+		}
+	}
+
+	if err := h.customerService.FindByID(c.Param("id"), &h.Customer); err != nil {
+		h.Form.Errors["general"] = "Could not find customer"
+		c.HTML(http.StatusNotFound, "account/transfer-money-form", h)
+		return
+	}
+
+	c.Header("HX-Trigger", "closeModal")
+	c.HTML(http.StatusOK, "account/transfer_money_oob", h)
+}
+
 func (h customerHandler) isOwner(customerID, userID string) bool {
 	var customer domain.Customer
 	if err := h.customerService.FindByID(customerID, &customer); err != nil {

internal/api/routes.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"fmt"
 	"html/template"
 	"net/http"
 	"os"
@@ -34,6 +35,7 @@ func Start() {
 		"mulfloat": func(a, b float64) float64 { return a * b },
 		"datetime": func(dateTime time.Time) string { return dateTime.Format("January 02, 2006 at 3:04 PM") },
 		"date":     func(date time.Time) string { return date.Format("January 02, 2006") },
+		"streq":    func(a, b interface{}) bool { return fmt.Sprintf("%v", a) == fmt.Sprintf("%v", b) },
 	})
 	// Load Templates
 	router.LoadHTMLGlob("templates/**/*")
@@ -137,7 +139,9 @@ func setupCustomerRoutes() {
 		DELETE(":id", middleware.UserAuth(), handler.Delete).
 		GET(":id/open-account", middleware.UserAuth(), handler.OpenAccountModal).
 		PUT(":id/open-account", middleware.UserAuth(), handler.OpenAccount).
-		POST(":id/settings", middleware.UserAuth(), handler.OpenSettingsModal)
+		POST(":id/settings", middleware.UserAuth(), handler.OpenSettingsModal).
+		POST(":id/open-transfer-modal", middleware.AnyAuth(), handler.OpenTransferMoneyModal).
+		PUT(":id/transfer", middleware.AnyAuth(), handler.TransferMoney)
 }
 
 func setupAccountRoutes() {

internal/domain/transaction.go

@@ -7,9 +7,10 @@ import (
 )
 
 const (
-	TransactionPending  = "PENDING"
-	TransactionApproved = "APPROVED"
-	TransactionDeclined = "DECLINED"
+	TransactionPending     = "PENDING"
+	TransactionApproved    = "APPROVED"
+	TransactionDeclined    = "DECLINED"
+	MAX_TRANSACTION_AMOUNT = 25_000_000
 )
 
 type Transaction struct {
@@ -41,7 +42,7 @@ func (t *Transaction) BeforeCreate(tx *gorm.DB) error {
 		return errors.New("amount cannot be 0")
 	}
 
-	if t.Amount > 25_000_000 {
+	if t.Amount > MAX_TRANSACTION_AMOUNT {
 		return errors.New("amount cannot be greater than 25,000,000")
 	}
 

internal/service/transaction_service.go

@@ -20,6 +20,7 @@ type Cashflow struct {
 type TransactionService interface {
 	Create(transaction *domain.Transaction) error
 	Update(id, userID, status string) error
+	TransferMoney(from domain.Account, to domain.Account, amount float64) error
 	SendMoney(fromAccount domain.Account, recipient domain.Customer, transaction *domain.Transaction) error
 	BulkTransfer(customerIDs []string, transaction *domain.Transaction) error
 	AutoPay(autoPay domain.AutoPay) error
@@ -112,6 +113,56 @@ func (ts transactionService) Create(transaction *domain.Transaction) error {
 	})
 }
 
+func (s transactionService) TransferMoney(from domain.Account, to domain.Account, amount float64) error {
+	return persistence.DB.Transaction(func(tx *gorm.DB) error {
+		if from.Balance < amount {
+			return errors.New("not enough money")
+		}
+
+		if from.ID == to.ID {
+			return errors.New("cannot transfer to same account")
+		}
+
+		if from.CustomerID != to.CustomerID {
+			return errors.New("cannot transfer to other customers accounts")
+		}
+
+		fromTransaction := domain.Transaction{}
+
+		from.Balance = utils.SafelySubtractDollars(from.Balance, amount)
+
+		fromTransaction.Amount = amount * -1
+		fromTransaction.Balance = from.Balance
+		fromTransaction.AccountID = from.ID
+		fromTransaction.Description = fmt.Sprintf("Money transfer to %s", to.Name)
+		fromTransaction.Status = domain.TransactionApproved
+
+		if err := s.accountService.UpdateBalance(strconv.Itoa(from.ID), &from); err != nil {
+			return err
+		}
+
+		if err := persistence.DB.Create(&fromTransaction).Error; err != nil {
+			return err
+		}
+
+		toTransaction := domain.Transaction{}
+
+		to.Balance = utils.SafelyAddDollars(to.Balance, amount)
+
+		toTransaction.Amount = amount
+		toTransaction.Balance = to.Balance
+		toTransaction.AccountID = to.ID
+		toTransaction.Description = fmt.Sprintf("Money transfer from %s", from.Name)
+		toTransaction.Status = domain.TransactionApproved
+
+		if err := s.accountService.UpdateBalance(strconv.Itoa(to.ID), &to); err != nil {
+			return err
+		}
+
+		return persistence.DB.Create(&toTransaction).Error
+	})
+}
+
 func (s transactionService) SendMoney(fromAccount domain.Account, recipient domain.Customer, transaction *domain.Transaction) error {
 	return persistence.DB.Transaction(func(tx *gorm.DB) error {
 		if fromAccount.Balance < transaction.Amount {