feat: adding qrcode to the json

controllers/connection_controller.go

@@ -27,7 +27,6 @@ func NewConnectionController(connectionService services.ConnectionService) Conne
 }
 
 func (cc *connectionController) Connect(ctx *gin.Context) {
-	// 1. Extract UserID from Context (set by AuthMiddleware)
 	userID, exists := ctx.Get("user_id")
 	if !exists {
 		utils.SendResponse[any, any](ctx, dto.AuthResponse{}, nil, http_error.UNAUTHORIZED)
@@ -35,20 +34,20 @@ func (cc *connectionController) Connect(ctx *gin.Context) {
 	}
 	accountID := userID.(uuid.UUID)
 
-	// 2. Bind JSON (Optional)
 	var req dto.ConnectRequest
 	_ = ctx.ShouldBindJSON(&req)
 
-	// 3. Trigger connection in background
-	go func() {
-		_ = cc.connectionService.Connect(context.Background(), accountID)
-	}()
+	qrCode, err := cc.connectionService.Connect(context.Background(), accountID)
+	if err != nil {
+		utils.SendResponse[any, any](ctx, dto.AuthResponse{}, nil, err)
+		return
+	}
 
-	// 4. Return Standardized Response
 	response := dto.ConnectResponse{
 		Message:   entity.CONNECTION_INIT_SUCCESS,
 		AccountID: accountID,
 		Details:   entity.QR_SCAN_INSTRUCTION,
+		QRCode:    qrCode,
 	}
 
 	utils.SendResponse[dto.ConnectResponse, any](ctx, dto.AuthResponse{}, response, nil)

go.mod

@@ -8,7 +8,6 @@ require (
 	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/google/uuid v1.6.0
 	github.com/joho/godotenv v1.5.1
-	github.com/mdp/qrterminal/v3 v3.2.1
 	go.mau.fi/whatsmeow v0.0.0-20251217143725-11cf47c62d32
 	golang.org/x/crypto v0.46.0
 	gorm.io/driver/postgres v1.6.0
@@ -59,8 +58,6 @@ require (
 	golang.org/x/net v0.48.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/sys v0.39.0 // indirect
-	golang.org/x/term v0.38.0 // indirect
 	golang.org/x/text v0.32.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
-	rsc.io/qr v0.2.0 // indirect
 )

middleware/auth_middleware.go

@@ -49,7 +49,6 @@ func (m *authMiddleware) RequireAuth() gin.HandlerFunc {
 			return
 		}
 
-		// Set user info in context
 		ctx.Set("user_id", claims.UserID)
 		ctx.Set("username", claims.Username)
 

models/dto/connection_dto.go

@@ -3,13 +3,14 @@ package dto
 import "github.com/google/uuid"
 
 type ConnectRequest struct {
-	// Add fields here if needed in the future, e.g. force refresh
+	
 }
 
 type ConnectResponse struct {
 	Message   string    `json:"message"`
 	AccountID uuid.UUID `json:"account_id"`
 	Details   string    `json:"details"`
+	QRCode    string    `json:"qr_code,omitempty"`
 }
 
 type ConnectionStatusResponse struct {

repositories/connection_repositories.go

@@ -27,18 +27,15 @@ type connectionRepository struct {
 	container *sqlstore.Container
 }
 
-// NewConnectionRepository initializes the SQLStore ONCE during app startup
 func NewConnectionRepository(db *gorm.DB) (ConnectionRepository, error) {
 	sqlDB, err := db.DB()
 	if err != nil {
 		return nil, http_error.ERR_DB_CONNECTION_FAILED
 	}
 
-	// whatsmeow requires its own logger for the store
+
 	dbLog := waLog.Stdout("Database", "INFO", true)
 
-	// We use "postgres" because your connection is Postgres.
-	// whatsmeow_device, whatsmeow_session, etc.
 	container := sqlstore.NewWithDB(sqlDB, entity.POSTGRES_DIALECT, dbLog)
 	if err := container.Upgrade(context.Background()); err != nil {
 		return nil, http_error.ERR_SQLSTORE_FAILED
@@ -53,7 +50,6 @@ func NewConnectionRepository(db *gorm.DB) (ConnectionRepository, error) {
 func (r *connectionRepository) InitializeClient(ctx context.Context, accountID uuid.UUID) (*whatsmeow.Client, <-chan whatsmeow.QRChannelItem, error) {
 	var acc entity.WhatsAppAccount
 
-	// 1. Find or Create your GORM entity
 	acc = entity.WhatsAppAccount{
 		ID:          accountID,
 		AccountName: "Default Device",
@@ -65,7 +61,6 @@ func (r *connectionRepository) InitializeClient(ctx context.Context, accountID u
 	var deviceStore *store.Device
 	var err error
 
-	// 2. Determine if we use an existing session (JID) or start a new one
 	if acc.JID != "" {
 		jid, parseErr := types.ParseJID(acc.JID)
 		if parseErr != nil {
@@ -73,7 +68,6 @@ func (r *connectionRepository) InitializeClient(ctx context.Context, accountID u
 		}
 		deviceStore, err = r.container.GetDevice(ctx, jid)
 	} else {
-		// No JID means this is a fresh account/new login
 		deviceStore = r.container.NewDevice()
 	}
 
@@ -81,11 +75,9 @@ func (r *connectionRepository) InitializeClient(ctx context.Context, accountID u
 		return nil, nil, http_error.ERR_DEVICE_STORE_FAILED
 	}
 
-	// 3. Create the whatsmeow client
 	clientLog := waLog.Stdout(fmt.Sprintf("Client-%s", accountID), "INFO", true)
 	client := whatsmeow.NewClient(deviceStore, clientLog)
 
-	// 4. Generate QR Channel if not logged in
 	var qrChan <-chan whatsmeow.QRChannelItem
 	if client.Store.ID == nil {
 		qrChan, _ = client.GetQRChannel(ctx)
@@ -95,7 +87,6 @@ func (r *connectionRepository) InitializeClient(ctx context.Context, accountID u
 }
 
 func (r *connectionRepository) UpdateAccountStatus(accountID uuid.UUID, jid string, isActive bool) error {
-	// Updates both the JID (bridge) and the active status in your GORM entity
 	return r.db.Model(&entity.WhatsAppAccount{ID: accountID}).Updates(map[string]interface{}{
 		"jid":       jid,
 		"is_active": isActive,
@@ -112,10 +103,9 @@ func (r *connectionRepository) DeleteDevice(accountID uuid.UUID) error {
 		jid, _ := types.ParseJID(acc.JID)
 		device, err := r.container.GetDevice(context.Background(), jid)
 		if err == nil && device != nil {
-			_ = device.Delete(context.Background()) // Pass context
+			_ = device.Delete(context.Background()) 
 		}
 	}
 
-	// Also clear from DB
 	return r.UpdateAccountStatus(accountID, "", false)
 }

services/auth_service.go

@@ -27,18 +27,15 @@ func NewAuthService(authRepo repositories.AuthRepository, jwtConfig config.JWTCo
 }
 
 func (s *authService) Register(req dto.RegisterRequest) (*dto.AuthResponse, error) {
-	// 1. Check if user exists
 	if _, err := s.authRepo.FindUserByUsername(req.Username); err == nil {
 		return nil, http_error.ERR_USER_ALREADY_EXISTS
 	}
 
-	// 2. Hash Password
 	hashedPassword, err := utils.HashPassword(req.Password)
 	if err != nil {
 		return nil, err
 	}
 
-	// 3. Create User
 	user := &entity.User{
 		Username: req.Username,
 		Password: hashedPassword,
@@ -48,7 +45,6 @@ func (s *authService) Register(req dto.RegisterRequest) (*dto.AuthResponse, erro
 		return nil, err
 	}
 
-	// 4. Generate Token
 	token, err := utils.GenerateToken(user.ID, user.Username, s.jwtConfig)
 	if err != nil {
 		return nil, http_error.ERR_TOKEN_GENERATION_FAILED
@@ -62,18 +58,15 @@ func (s *authService) Register(req dto.RegisterRequest) (*dto.AuthResponse, erro
 }
 
 func (s *authService) Login(req dto.LoginRequest) (*dto.AuthResponse, error) {
-	// 1. Find User
 	user, err := s.authRepo.FindUserByUsername(req.Username)
 	if err != nil {
 		return nil, http_error.ERR_USER_NOT_FOUND
 	}
 
-	// 2. Check Password
 	if !utils.CheckPasswordHash(req.Password, user.Password) {
 		return nil, http_error.ERR_WRONG_PASSWORD
 	}
 
-	// 3. Generate Token
 	token, err := utils.GenerateToken(user.ID, user.Username, s.jwtConfig)
 	if err != nil {
 		return nil, http_error.ERR_TOKEN_GENERATION_FAILED

services/connection_service.go

@@ -3,19 +3,18 @@ package services
 import (
 	"context"
 	"fmt"
-	"os"
 	"sync"
+	"time"
 	http_error "whatsapp-backend/models/error"
 	"whatsapp-backend/repositories"
 
 	"github.com/google/uuid"
-	"github.com/mdp/qrterminal/v3"
 	"go.mau.fi/whatsmeow"
 	"go.mau.fi/whatsmeow/types/events"
 )
 
 type ConnectionService interface {
-	Connect(ctx context.Context, accountID uuid.UUID) error
+	Connect(ctx context.Context, accountID uuid.UUID) (string, error)
 	GetActiveClient(accountID uuid.UUID) (*whatsmeow.Client, error)
 }
 
@@ -30,35 +29,33 @@ func NewConnectionService(connectionRepo repositories.ConnectionRepository) Conn
 	}
 }
 
-func (s *connectionService) Connect(ctx context.Context, accountID uuid.UUID) error {
+func (s *connectionService) Connect(ctx context.Context, accountID uuid.UUID) (string, error) {
 	if existingClient, ok := s.activeClients.Load(accountID); ok {
 		client := existingClient.(*whatsmeow.Client)
 		if client.IsConnected() {
-			return nil // Already connected, no action needed
+			return "", nil
 		}
 	}
 
-	// 2. Fetch or Init Client from Repository
-	// We assume your Repo now has a method that takes accountID and returns (client, qrChan, err)
-	// by looking up the entity in the DB first.
 	client, qrChan, err := s.connectionRepo.InitializeClient(ctx, accountID)
 	if err != nil {
-		return http_error.ERR_CLIENT_INIT_FAILED
+		return "", http_error.ERR_CLIENT_INIT_FAILED
 	}
 
-	// 3. Register Event Handlers
-	// This is the "hook" that updates your database when the status changes
 	client.AddEventHandler(func(evt interface{}) {
 		s.handleWhatsAppEvent(accountID, client, evt)
 	})
 
-	// 4. Handle QR Channel in a background goroutine
+	qrCodeChan := make(chan string, 1)
+
 	if qrChan != nil {
 		go func() {
 			for evt := range qrChan {
 				if evt.Event == "code" {
-					fmt.Printf("\n[ACCOUNT %s] SCAN THIS QR CODE:\n", accountID)
-					qrterminal.GenerateHalfBlock(evt.Code, qrterminal.L, os.Stdout)
+					select {
+					case qrCodeChan <- evt.Code:
+					default:
+					}
 				} else {
 					fmt.Printf("[ACCOUNT %s] Login Event: %s\n", accountID, evt.Event)
 				}
@@ -66,16 +63,23 @@ func (s *connectionService) Connect(ctx context.Context, accountID uuid.UUID) er
 		}()
 	}
 
-	// 5. Connect to WhatsApp Socket
 	if err := client.Connect(); err != nil {
-		_ = s.connectionRepo.DeleteDevice(accountID) // CLEANUP
-		return http_error.ERR_CLIENT_CONNECT_FAILED
+		_ = s.connectionRepo.DeleteDevice(accountID)
+		return "", http_error.ERR_CLIENT_CONNECT_FAILED
 	}
 
-	// 6. Store in-memory
-	s.activeClients.Store(accountID, client)
-
-	return nil
+	select {
+		case code := <-qrCodeChan:
+			s.activeClients.Store(accountID, client)
+			return code, nil
+		case <-time.After(3 * time.Second):
+			if client.IsConnected() {
+				s.activeClients.Store(accountID, client)
+				return "", nil
+			}
+			s.activeClients.Store(accountID, client)
+			return "", nil
+	}
 }
 
 func (s *connectionService) GetActiveClient(accountID uuid.UUID) (*whatsmeow.Client, error) {
@@ -86,23 +90,18 @@ func (s *connectionService) GetActiveClient(accountID uuid.UUID) (*whatsmeow.Cli
 	return val.(*whatsmeow.Client), nil
 }
 
-// handleWhatsAppEvent coordinates between the live socket and your database
 func (s *connectionService) handleWhatsAppEvent(accountID uuid.UUID, client *whatsmeow.Client, evt interface{}) {
 	switch evt.(type) {
 	case *events.Connected:
-		// When the socket confirms connection, update the JID in your DB entity
 		if client.Store.ID != nil {
 			_ = s.connectionRepo.UpdateAccountStatus(accountID, client.Store.ID.String(), true)
 		}
 
 	case *events.LoggedOut:
-		// Cleanup when the user unlinks the device from their phone
 		s.activeClients.Delete(accountID)
 		_ = s.connectionRepo.UpdateAccountStatus(accountID, "", false)
 
 	case *events.Disconnected:
-		// Temporary network loss - whatsmeow handles auto-reconnect,
-		// but we might want to log this.
 		fmt.Printf("Account %s disconnected from WhatsApp\n", accountID)
 	}
 }