add: send mail to stmp server

Author: virakthaka

README.md

@@ -1,12 +1,12 @@
 # Golang CRUD Service
 
-This is a sample CRUD service built with **Golang**, demonstrating a layered architecture that separates concerns into handler, service, repository, and model layers. The project uses **TiDB** as the relational database, **Redis** for `caching` and `pub/sub` in-memory operations, and **JWT** for authentication.
+This is a sample CRUD service built with **Golang**, demonstrating a layered architecture that separates concerns into handler, service, repository, and model layers. The project uses **TiDB** as the relational database, **Redis** for `caching` and `async tasks` in-memory operations, and **JWT** for authentication.
 
-## 🚀 Project Purpose
+## Project Purpose
 
 Build a sample CRUD service API with Golang to showcase code structure and common best practices in web API development.
 
-## 🛠️ Tech Stack
+## Tech Stack
 
 - **[Golang](https://golang.org)** — Core programming language
 - **[Fiber](https://gofiber.io)** — Fast HTTP router
@@ -18,7 +18,7 @@ Build a sample CRUD service API with Golang to showcase code structure and commo
 - **[Redis Stream](https://redis.io/docs/latest/develop/data-types/streams)** — Background task queue using consumer group
 - **[JWT](https://github.com/golang-jwt/jwt)** — JSON Web Token implementation for authentication
 
-## 📁 Project Structure
+## Project Structure
 
 ```
 ├── cmd/
@@ -47,22 +47,26 @@ Build a sample CRUD service API with Golang to showcase code structure and commo
 │   └── dto/                       # DTOs for transforming request/response data
 ```
 
-## 📌 Key Concepts
+## Key Concepts
 
 - **Layered Architecture**: Divides the project into clear layers for maintainability and scalability.
-- **Goroutines**: Background task workers use `goroutines` to run concurrently and process `redis stream` jobs efficiently.
+- **Goroutines**: Background task workers use `goroutines` to run concurrent `redis stream` jobs efficiently.
 - **Rate Limit**: Failed attempts and request limited using `redis` to prevent abuse `429 Too Many Requests`.
 - **DTO Pattern**: Uses `copier` to map between internal models and request/response structures.
 - **Validation**: Ensures request payloads are validated with `go-playground/validator`.
 - **ORM**: Leverages `GORM` to interact with `TiDB` in a concise and type-safe way.
+- **SMTP**: Standard `net/smtp` package for email sending to SMTP server.
 
-## 🧪 Running the Project
+> 💡 Tip: If you're using Gmail SMTP: allow **"Less secure apps"** (not recommended)
+
+## Running the Project
 
 1. **Configure Environment**
    Create a `.env` file. find in a `.env.example` file for environment:
-   - JWT Secret key
-   - TiDB connection
    - Redis connection
+   - TiDB connection
+   - Email configure
+   - JWT Secret key
 
 2. **Run the App**
    ```bash
@@ -79,11 +83,12 @@ Build a sample CRUD service API with Golang to showcase code structure and commo
    docker compose up -d
    ```
 
-## 🔧 Future Enhancements
+
+## Future Enhancements
 
 - Add unit tests and integration tests
 - Add Swagger/OpenAPI documentation
 
-## 📄 License
+## License
 
 This project is open-source and available under the [MIT License]().

config/config.go

@@ -21,6 +21,7 @@ type (
 		App      `mapstructure:",squash"`
 		Log      `mapstructure:",squash"`
 		DB       `mapstructure:",squash"`
+		Email    `mapstructure:",squash"`
 		Redis    `mapstructure:",squash"`
 		PermLogs `mapstructure:",squash"`
 		JWT      `mapstructure:",squash"`
@@ -47,6 +48,13 @@ type (
 		AutoMigrate bool   `mapstructure:"db_auto_migrate"`
 	}
 
+	Email struct {
+		Host     string `mapstructure:"email_host"`
+		Port     string `mapstructure:"email_port"`
+		Username string `mapstructure:"email_username"`
+		Password string `mapstructure:"email_password"`
+	}
+
 	Redis struct {
 		Addr     string `mapstructure:"redis_addr"`
 		Port     string `mapstructure:"redis_port"`
@@ -113,6 +121,11 @@ func Init() error {
 	pflag.String("db_use_ssl", "", "database use ssl")
 	pflag.Bool("db_auto_migrate", false, "database auto migrate")
 
+	pflag.String("email_host", "", "database host")
+	pflag.String("email_port", "", "database port")
+	pflag.String("email_username", "", "database username")
+	pflag.String("email_password", "", "database password")
+
 	pflag.String("redis_addr", "", "redis address")
 	pflag.String("redis_port", "6379", "redis port")
 	pflag.String("redis_pwd", "", "redis password")
@@ -152,6 +165,12 @@ func Init() error {
 			UseSSL:      viper.GetString("db_use_ssl"),
 			AutoMigrate: viper.GetBool("db_auto_migrate"),
 		},
+		Email: Email{
+			Host:     viper.GetString("email_host"),
+			Port:     viper.GetString("email_port"),
+			Username: viper.GetString("email_username"),
+			Password: viper.GetString("email_password"),
+		},
 		Redis: Redis{
 			Addr:     viper.GetString("redis_addr"),
 			Port:     viper.GetString("redis_port"),

internal/repository/user.go

@@ -7,6 +7,7 @@ import (
 )
 
 type User interface {
+	GetUsername(email string) (string, error)
 	GetUser(username string) (model.User, error)
 	UpdatePass(username, password string) error
 }
@@ -19,6 +20,13 @@ func NewUser(db *gorm.DB) User {
 	return &user{db: db}
 }
 
+func (h *user) GetUsername(email string) (username string, err error) {
+	err = h.db.Model(&model.User{}).Select("username").
+		Where("email = ?", email).
+		Scan(&username).Error
+	return username, err
+}
+
 func (h *user) GetUser(username string) (entity model.User, err error) {
 	return entity, h.db.First(&entity, "username = ?", username).Error
 }

internal/service/auth.go

@@ -8,6 +8,7 @@ import (
 	"learn-fiber/internal/dto"
 	"learn-fiber/internal/model"
 	"learn-fiber/internal/repository"
+	"learn-fiber/internal/task/consumer"
 	"learn-fiber/internal/task/producer"
 	"learn-fiber/pkg/crypto"
 	"learn-fiber/pkg/redis"
@@ -46,14 +47,6 @@ func (h *auth) Info(username string) (model.User, error) {
 
 func (h *auth) Login(ip string, req dto.LoginRequest) (token model.Token, err error) {
 	key := "attempt:" + req.Username + ":" + ip
-	_ = producer.Send(map[string]interface{}{
-		"cmd": "send_email",
-		"data": map[string]interface{}{
-			"title": "Change account password",
-			"body":  "Your account password has been changed successfully",
-			"to":    "user.Email",
-		},
-	})
 	user, err := h.repo.GetUser(req.Username)
 	if err != nil {
 		if err = attempts(key); err != nil {
@@ -112,14 +105,14 @@ func (h *auth) RenewToken(ip string, req dto.RenewTokenRequest) (token model.Tok
 	if err != nil {
 		return token, errors.New("refresh token invalid")
 	}
-	token.RefreshToken = uuid.NewString()
 	token.Expired = time.Now().Add(time.Hour).Unix()
 	claims := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
 		"username": user.Username,
 		"role":     user.Role,
 		"exp":      token.Expired,
 	})
 	token.Ip = ip
+	token.RefreshToken = uuid.NewString()
 	token.AccessToken, err = claims.SignedString([]byte(config.Cfg.JWT.Secret))
 	if err != nil {
 		return token, err
@@ -150,13 +143,16 @@ func (h *auth) ChangePassword(username string, req dto.ChangePassRequest) error
 	if err != nil {
 		return err
 	}
-	_ = producer.Send(map[string]interface{}{
-		"cmd": "send_email",
-		"data": map[string]interface{}{
-			"title": "Change account password",
-			"body":  "Your account password has been changed successfully",
-			"to":    user.Email,
-		},
-	})
+	data := consumer.EmailData{
+		Body:  "Your account password has been changed successfully",
+		Title: "Change Account Password",
+		To:    user.Email,
+	}
+	sendMail(data)
 	return h.repo.UpdatePass(username, hashPass)
 }
+
+func sendMail(data consumer.EmailData) {
+	message := consumer.EmailCommand{Cmd: "send_email", Data: data}
+	producer.Send(message)
+}

internal/task/consumer/consumer.go

@@ -1,17 +1,39 @@
 package consumer
 
 import (
+	"encoding/json"
 	"fmt"
 	"gorm.io/gorm"
 )
 
+type EmailData struct {
+	Title string `json:"title"`
+	Body  string `json:"body"`
+	To    string `json:"to"`
+}
+
+type EmailCommand struct {
+	Cmd  string    `json:"cmd"`
+	Data EmailData `json:"data"`
+}
+
 func Listener(db *gorm.DB, data map[string]interface{}) {
-	if cmd, ok := data["cmd"]; ok {
-		switch cmd {
+	if cmd, err := covert(data); err == nil {
+		switch cmd.Cmd {
 		case "send_email":
-			SendEmail(db, data)
+			SendEmail(db, cmd.Data)
 		default:
-			fmt.Printf("command `%s` not found", cmd)
+			fmt.Printf("command `%s` not found", cmd.Cmd)
 		}
 	}
 }
+
+func covert(data map[string]interface{}) (cmd EmailCommand, err error) {
+	bytes, err := json.Marshal(data)
+	if err != nil {
+		return cmd, err
+	}
+	_ = json.Unmarshal([]byte(data["data"].(string)), &cmd.Data)
+	_ = json.Unmarshal(bytes, &cmd)
+	return cmd, nil
+}

internal/task/consumer/handler.go

@@ -2,9 +2,16 @@ package consumer
 
 import (
 	"fmt"
+	"learn-fiber/internal/repository"
+	"learn-fiber/pkg/mail"
+
 	"gorm.io/gorm"
 )
 
-func SendEmail(db *gorm.DB, data interface{}) {
+func SendEmail(db *gorm.DB, data EmailData) {
 	fmt.Println("Processing sending email", data)
+	if username, err := repository.NewUser(db).GetUsername(data.To); err == nil {
+		r := mail.NewRequest(data.To, data.Title, data.Body, "", username)
+		r.Send("templates/change-pass.html")
+	}
 }

internal/task/producer/producer.go

@@ -2,16 +2,21 @@ package producer
 
 import (
 	"encoding/json"
+	"learn-fiber/internal/task/consumer"
 	"learn-fiber/pkg/redis"
 )
 
-func Send(payload map[string]interface{}) error {
-	if data, ok := payload["data"]; ok {
-		body, err := json.Marshal(data)
-		if err != nil {
-			return err
+func Send(payload consumer.EmailCommand) {
+	if result := toMap(payload); result != nil {
+		if body, err := json.Marshal(payload.Data); err == nil {
+			result["data"] = string(body)
+			redis.EnqueueTask(result)
 		}
-		payload["data"] = string(body)
 	}
-	return redis.EnqueueTask(payload).Err()
+}
+
+func toMap(v interface{}) (result map[string]interface{}) {
+	b, _ := json.Marshal(v)
+	_ = json.Unmarshal(b, &result)
+	return result
 }

pkg/mail/mailer.go

@@ -0,0 +1,66 @@
+package mail
+
+import (
+	"bytes"
+	"fmt"
+	"html/template"
+	"learn-fiber/config"
+	"log"
+	"net/smtp"
+)
+
+type Request struct {
+	Username string
+	Subject  string
+	Link     string
+	Body     string
+	to       string
+}
+
+func NewRequest(to, subject, body, link, username string) *Request {
+	return &Request{
+		Username: username,
+		Subject:  subject,
+		Link:     link,
+		Body:     body,
+		to:       to,
+	}
+}
+
+func (h *Request) parseTemplate(fileName string) error {
+	temp, err := template.ParseFiles(fileName)
+	if err != nil {
+		return err
+	}
+	var buffer bytes.Buffer
+	if err = temp.Execute(&buffer, h); err != nil {
+		return err
+	}
+	h.Body = buffer.String()
+	return nil
+}
+
+func (h *Request) sendMail() error {
+	addr := fmt.Sprintf("%s:%s", config.Cfg.Email.Host, config.Cfg.Email.Port)
+	msg := "MIME-version: 1.0;\nContent-Type: text/html; charset=\"UTF-8\";\n"
+	msg += "From: " + config.Cfg.Email.Username + "\n"
+	msg += "Subject: " + h.Subject + "\n"
+	msg += "To: " + h.to + "\n\n"
+	msg += h.Body
+
+	auth := smtp.PlainAuth("", config.Cfg.Email.Username, config.Cfg.Email.Password, config.Cfg.Email.Host)
+	err := smtp.SendMail(addr, auth, config.Cfg.Email.Username, []string{h.to}, []byte(msg))
+	return err
+}
+
+func (h *Request) Send(template string) {
+	if err := h.parseTemplate(template); err != nil {
+		log.Fatal(err)
+	}
+	if err := h.sendMail(); err != nil {
+		log.Printf("Failed to send to %s\n", h.to)
+		log.Print(err)
+		return
+	}
+	log.Printf("Email sent to %s\n", h.to)
+}