refactor database connection and balance management logic

Author: Armin

app/app.go

@@ -1,19 +1,19 @@
 package app
 
 import (
-	"fmt"
 	"log/slog"
 	"os"
+	"sms-gateway/config"
+	"sms-gateway/pkg/db"
 
 	_ "github.com/go-sql-driver/mysql"
-	"github.com/jmoiron/sqlx"
 	"github.com/labstack/echo/v4"
 )
 
 var (
 	Echo   *echo.Echo
 	Logger *slog.Logger
-	DB     *sqlx.DB
+	DB     *db.DB
 )
 
 func Init() {
@@ -27,43 +27,20 @@ func initLogger() {
 	Logger = slog.New(handler)
 }
 
-type dbConfig struct {
-	Username string
-	Password string
-	Host     string
-	Port     int
-	DBName   string
-}
-
-func ConnectionString(dbConfig dbConfig) string {
-	url := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s",
-		dbConfig.Username,
-		dbConfig.Password,
-		dbConfig.Host,
-		dbConfig.Port,
-		dbConfig.DBName)
-	return url
-}
-
 func initDB() {
 	var err error
-	DB, err = sqlx.Open("mysql", ConnectionString(dbConfig{
-		Username: "sms_user",
-		Password: "sms_pass",
-		Host:     "localhost",
-		Port:     3306,
-		DBName:   "sms_gateway",
-	}))
+	DB, err = db.ConnectDB(db.Config{
+		Username: config.DBUsername,
+		Password: config.DBPassword,
+		Host:     config.DBHost,
+		Port:     config.DBPort,
+		DBName:   config.DBName,
+	})
 	if err != nil {
 		panic(err)
 	}
-
-	if err := DB.Ping(); err != nil {
-		panic(err)
-	}
-
 	// migrate
-
+	// seed
 }
 
 func initEcho() {

config/config.go

@@ -1,14 +1,31 @@
 package config
 
-import "sms-gateway/pkg/env"
+import (
+	"sms-gateway/pkg/env"
+	"strconv"
+)
 
 var (
 	AppName       string
 	AppBaseURL    string
 	AppListenAddr string
+	DBUsername    string
+	DBPassword    string
+	DBHost        string
+	DBPort        int
+	DBName        string
 )
 
 func init() {
 	AppName = env.Default("APP_NAME", "sms-gateway")
 	AppListenAddr = env.RequiredNotEmpty("LISTEN_ADDR")
+	DBUsername = env.RequiredNotEmpty("DB_USER_NAME")
+	DBPassword = env.RequiredNotEmpty("DB_PASSWORD")
+	DBHost = env.RequiredNotEmpty("DB_HOST")
+	port, err := strconv.Atoi(env.RequiredNotEmpty("DB_PORT"))
+	if err != nil {
+		panic("invalid DB_PORT: " + err.Error())
+	}
+	DBPort = port
+	DBName = env.RequiredNotEmpty("DB_NAME")
 }

internal/balance/db/db.sql

@@ -11,15 +11,9 @@ values (1,100);
 
 
 CREATE TABLE user_transactions (
-                                   transaction_id BIGINT AUTO_INCREMENT PRIMARY KEY,
-                                   user_id BIGINT NOT NULL,
-                                   amount BIGINT NOT NULL,  -- Positive for deposit, negative for withdrawal
-                                   new_balance BIGINT NOT NULL,  -- Balance after this transaction
-                                   transaction_type VARCHAR(50) NOT NULL,  -- e.g., 'deposit', 'withdrawal', 'transfer'
-                                   description TEXT,
-                                   created_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
-
-                                   INDEX idx_user_id_created_at (user_id, created_at DESC),
-                                   INDEX idx_transaction_type (transaction_type),
-                                   FOREIGN KEY (user_id) REFERENCES user_balances(user_id) ON DELETE CASCADE
+        user_id BIGINT NOT NULL,
+        amount BIGINT NOT NULL,  -- Positive for deposit, negative for withdrawal
+        transaction_type VARCHAR(50) NOT NULL,  -- e.g., 'deposit', 'withdrawal', 'transfer'
+        description TEXT,
+        created_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
 ) ENGINE=InnoDB;

internal/balance/service.go

@@ -4,17 +4,24 @@ import (
 	"context"
 	"database/sql"
 	"errors"
+	"fmt"
 	"sms-gateway/app"
 	"sms-gateway/internal/model"
 )
 
+type transactionType string
+
+const (
+	Withdrawal transactionType = "withdrawal"
+)
+
 type UserHasEnoughBalanceRequest struct {
 	CustomerID int64
 	Quantity   int
 	Type       model.Type
 }
 
-func UserHasEnoughBalance(ctx context.Context, req UserHasEnoughBalanceRequest) (bool, error) {
+func UserHasBalance(ctx context.Context, req UserHasEnoughBalanceRequest) (bool, error) {
 
 	const query = `SELECT balance FROM user_balances WHERE user_id = ?`
 	var balance int64
@@ -29,6 +36,56 @@ func UserHasEnoughBalance(ctx context.Context, req UserHasEnoughBalanceRequest)
 	return balance >= price, nil
 }
 
+type DeductBalanceRequest struct {
+	CustomerID int64
+	Quantity   int
+	Type       model.Type
+}
+
+func DeductBalance(ctx context.Context, req DeductBalanceRequest) (err error) {
+	price := calculatePrice(req.Type, req.Quantity)
+
+	tx, err := app.DB.DB.BeginTxx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err != nil {
+			_ = tx.Rollback()
+		}
+	}()
+
+	const updateBalanceQuery = `UPDATE user_balances SET balance = balance - ? WHERE user_id = ? AND balance >= ?`
+	res, err := tx.ExecContext(ctx, updateBalanceQuery, price, req.CustomerID, price)
+	if err != nil {
+		return err
+	}
+
+	rows, err := res.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if rows == 0 {
+		return errors.New("insufficient balance")
+	}
+
+	const insertTransactionQuery = `INSERT INTO user_transactions (user_id, amount, transaction_type, description) VALUES (?, ?, ?, ?)`
+	if _, err = tx.ExecContext(ctx,
+		insertTransactionQuery,
+		req.CustomerID,
+		-price,
+		Withdrawal,
+		descriptionGenerator(req.Type, req.Quantity)); err != nil {
+		return err
+	}
+
+	if err = tx.Commit(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func calculatePrice(Type model.Type, Quantity int) int64 {
 	return int64(getPricePerType(Type) * Quantity)
 }
@@ -40,3 +97,7 @@ func getPricePerType(t model.Type) int {
 	}
 	return 1
 }
+
+func descriptionGenerator(t model.Type, q int) string {
+	return fmt.Sprintf("بابت خرید %d پیامک تایپ %s", q, t)
+}

internal/sms/handler.go

@@ -25,24 +25,29 @@ func SendHandler(c echo.Context) error {
 	app.Logger.Info("", "s", s)
 
 	// check user balance
-	hasBalance, err := balance.UserHasEnoughBalance(c.Request().Context(), balance.UserHasEnoughBalanceRequest{
+	hasBalance, err := balance.UserHasBalance(c.Request().Context(), balance.UserHasEnoughBalanceRequest{
 		CustomerID: s.CustomerID,
 		Quantity:   len(s.Recipients),
 		Type:       s.Type,
 	})
 	if err != nil {
-		app.Logger.Error("UserHasEnoughBalance ", "err", err)
+		app.Logger.Error("UserHasBalance ", "err", err)
 		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "internal error"})
 	}
 	if !hasBalance {
 		app.Logger.Info("User Has Not Enough Balance ", "user id ", s.CustomerID)
 		return c.JSON(http.StatusPaymentRequired, map[string]string{"error": "dont have "})
 	}
 
-	app.Logger.Info("user has Enough Balance", "s", s)
+	if err := balance.DeductBalance(c.Request().Context(), balance.DeductBalanceRequest{
+		CustomerID: s.CustomerID,
+		Quantity:   len(s.Recipients),
+		Type:       s.Type,
+	}); err != nil {
+		app.Logger.Error("DeductBalance ", "err", err)
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "internal error"})
+	}
 
-	// if not ok return err
-	//else cut down the balance
 	//then send it in quew
 
 	return c.JSON(http.StatusOK, nil)

pkg/db/db.go

@@ -0,0 +1,50 @@
+package db
+
+import (
+	"fmt"
+
+	_ "github.com/go-sql-driver/mysql"
+
+	"github.com/jmoiron/sqlx"
+)
+
+type Config struct {
+	Username string
+	Password string
+	Host     string
+	Port     int
+	DBName   string
+}
+
+type DB struct {
+	*sqlx.DB
+}
+
+func ConnectionString(dbConfig Config) string {
+	url := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s",
+		dbConfig.Username,
+		dbConfig.Password,
+		dbConfig.Host,
+		dbConfig.Port,
+		dbConfig.DBName)
+	return url
+}
+
+func ConnectDB(config Config) (*DB, error) {
+	db, err := sqlx.Open("mysql", ConnectionString(Config{
+		Username: config.Username,
+		Password: config.Password,
+		Host:     config.Host,
+		Port:     config.Port,
+		DBName:   config.DBName,
+	}))
+	if err != nil {
+		return nil, err
+	}
+
+	if err := db.Ping(); err != nil {
+		return nil, err
+	}
+
+	return &DB{db}, nil
+}