Merge pull request #20 from orion-ai-project/dev

feat: adding whatsapp/socket for websocket connection

controllers/socket_controller.go

@@ -0,0 +1,41 @@
+package controllers
+
+import (
+	"log"
+	http_error "whatsapp-backend/models/error"
+	"whatsapp-backend/services"
+	"whatsapp-backend/utils"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type SocketController interface {
+	HandleWebSocket(ctx *gin.Context)
+}
+
+type socketController struct {
+	socketService services.SocketService
+}
+
+func NewSocketController(socketService services.SocketService) SocketController {
+	return &socketController{socketService: socketService}
+}
+
+// HandleWebSocket godoc
+// @Summary      Connect to WebSocket
+// @Description  Upgrade HTTP connection to WebSocket for real-time updates
+// @Tags         whatsapp
+// @Security     BearerAuth
+// @Success      101
+// @Router       /whatsapp/socket [get]
+func (c *socketController) HandleWebSocket(ctx *gin.Context) {
+	userID, exists := ctx.Get("user_id")
+	if !exists {
+		log.Println("[WebSocket] User ID not found in context")
+		utils.SendResponse[any, any](ctx, nil, nil, http_error.UNAUTHORIZED)
+		return
+	}
+	accountID := userID.(uuid.UUID)
+	c.socketService.HandleConnection(ctx.Writer, ctx.Request, accountID)
+}

docs/docs.go

@@ -443,7 +443,70 @@ const docTemplate = `{
                 }
             }
         },
-        "/chat/send": {
+        "/chat/send_img": {
+            "post": {
+                "security": [
+                    {
+                        "BearerAuth": []
+                    }
+                ],
+                "description": "Send an image to a WhatsApp number via file upload",
+                "consumes": [
+                    "multipart/form-data"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "chat"
+                ],
+                "summary": "Send WhatsApp image",
+                "parameters": [
+                    {
+                        "type": "file",
+                        "description": "Image file to send",
+                        "name": "image",
+                        "in": "formData",
+                        "required": true
+                    },
+                    {
+                        "type": "string",
+                        "example": "628123456789",
+                        "description": "Recipient phone number",
+                        "name": "recipient",
+                        "in": "formData",
+                        "required": true
+                    },
+                    {
+                        "type": "string",
+                        "description": "Image caption",
+                        "name": "caption",
+                        "in": "formData"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.SendMessageResponse"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorResponse"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorResponse"
+                        }
+                    }
+                }
+            }
+        },
+        "/chat/send_msg": {
             "post": {
                 "security": [
                     {
@@ -460,7 +523,7 @@ const docTemplate = `{
                 "tags": [
                     "chat"
                 ],
-                "summary": "Send WhatsApp message",
+                "summary": "Send WhatsApp text message",
                 "parameters": [
                     {
                         "description": "Send Message Request",
@@ -545,6 +608,25 @@ const docTemplate = `{
                 }
             }
         },
+        "/whatsapp/socket": {
+            "get": {
+                "security": [
+                    {
+                        "BearerAuth": []
+                    }
+                ],
+                "description": "Upgrade HTTP connection to WebSocket for real-time updates",
+                "tags": [
+                    "whatsapp"
+                ],
+                "summary": "Connect to WebSocket",
+                "responses": {
+                    "101": {
+                        "description": "Switching Protocols"
+                    }
+                }
+            }
+        },
         "/whatsapp/status": {
             "get": {
                 "security": [

docs/swagger.json

@@ -436,7 +436,70 @@
                 }
             }
         },
-        "/chat/send": {
+        "/chat/send_img": {
+            "post": {
+                "security": [
+                    {
+                        "BearerAuth": []
+                    }
+                ],
+                "description": "Send an image to a WhatsApp number via file upload",
+                "consumes": [
+                    "multipart/form-data"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "chat"
+                ],
+                "summary": "Send WhatsApp image",
+                "parameters": [
+                    {
+                        "type": "file",
+                        "description": "Image file to send",
+                        "name": "image",
+                        "in": "formData",
+                        "required": true
+                    },
+                    {
+                        "type": "string",
+                        "example": "628123456789",
+                        "description": "Recipient phone number",
+                        "name": "recipient",
+                        "in": "formData",
+                        "required": true
+                    },
+                    {
+                        "type": "string",
+                        "description": "Image caption",
+                        "name": "caption",
+                        "in": "formData"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/dto.SendMessageResponse"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorResponse"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/dto.ErrorResponse"
+                        }
+                    }
+                }
+            }
+        },
+        "/chat/send_msg": {
             "post": {
                 "security": [
                     {
@@ -453,7 +516,7 @@
                 "tags": [
                     "chat"
                 ],
-                "summary": "Send WhatsApp message",
+                "summary": "Send WhatsApp text message",
                 "parameters": [
                     {
                         "description": "Send Message Request",
@@ -538,6 +601,25 @@
                 }
             }
         },
+        "/whatsapp/socket": {
+            "get": {
+                "security": [
+                    {
+                        "BearerAuth": []
+                    }
+                ],
+                "description": "Upgrade HTTP connection to WebSocket for real-time updates",
+                "tags": [
+                    "whatsapp"
+                ],
+                "summary": "Connect to WebSocket",
+                "responses": {
+                    "101": {
+                        "description": "Switching Protocols"
+                    }
+                }
+            }
+        },
         "/whatsapp/status": {
             "get": {
                 "security": [

docs/swagger.yaml

@@ -453,7 +453,48 @@ paths:
       summary: Fetch WhatsApp contacts
       tags:
       - chat
-  /chat/send:
+  /chat/send_img:
+    post:
+      consumes:
+      - multipart/form-data
+      description: Send an image to a WhatsApp number via file upload
+      parameters:
+      - description: Image file to send
+        in: formData
+        name: image
+        required: true
+        type: file
+      - description: Recipient phone number
+        example: "628123456789"
+        in: formData
+        name: recipient
+        required: true
+        type: string
+      - description: Image caption
+        in: formData
+        name: caption
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/dto.SendMessageResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/dto.ErrorResponse'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/dto.ErrorResponse'
+      security:
+      - BearerAuth: []
+      summary: Send WhatsApp image
+      tags:
+      - chat
+  /chat/send_msg:
     post:
       consumes:
       - application/json
@@ -482,7 +523,7 @@ paths:
             $ref: '#/definitions/dto.ErrorResponse'
       security:
       - BearerAuth: []
-      summary: Send WhatsApp message
+      summary: Send WhatsApp text message
       tags:
       - chat
   /whatsapp/connect:
@@ -518,6 +559,17 @@ paths:
       summary: Connect new WhatsApp account
       tags:
       - whatsapp
+  /whatsapp/socket:
+    get:
+      description: Upgrade HTTP connection to WebSocket for real-time updates
+      responses:
+        "101":
+          description: Switching Protocols
+      security:
+      - BearerAuth: []
+      summary: Connect to WebSocket
+      tags:
+      - whatsapp
   /whatsapp/status:
     get:
       consumes:

go.mod

@@ -8,12 +8,14 @@ require (
 	github.com/go-playground/validator/v10 v10.29.0
 	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
 	github.com/joho/godotenv v1.5.1
 	github.com/swaggo/files v1.0.1
 	github.com/swaggo/gin-swagger v1.6.1
 	github.com/swaggo/swag v1.16.6
 	go.mau.fi/whatsmeow v0.0.0-20251217143725-11cf47c62d32
 	golang.org/x/crypto v0.46.0
+	google.golang.org/protobuf v1.36.11
 	gorm.io/driver/postgres v1.6.0
 	gorm.io/gorm v1.31.1
 )
@@ -77,5 +79,4 @@ require (
 	golang.org/x/sys v0.39.0 // indirect
 	golang.org/x/text v0.32.0 // indirect
 	golang.org/x/tools v0.40.0 // indirect
-	google.golang.org/protobuf v1.36.11 // indirect
 )

go.sum

@@ -82,6 +82,8 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=

middleware/auth_middleware.go

@@ -29,14 +29,14 @@ func NewAuthMiddleware(jwtConfig config.JWTConfig, authRepo repositories.AuthRep
 func (m *authMiddleware) RequireAuth() gin.HandlerFunc {
 	return func(ctx *gin.Context) {
 		authHeader := ctx.GetHeader("Authorization")
-		if authHeader == "" {
-			utils.SendResponse[any, any](ctx, nil, nil, http_error.UNAUTHORIZED)
-			ctx.Abort()
-			return
-		}
+		tokenString := ""
 
-		tokenString := strings.TrimPrefix(authHeader, "Bearer")
-		tokenString = strings.TrimSpace(tokenString)
+		if authHeader != "" {
+			tokenString = strings.TrimPrefix(authHeader, "Bearer")
+			tokenString = strings.TrimSpace(tokenString)
+		} else {
+			tokenString = ctx.Query("token")
+		}
 
 		if tokenString == "" {
 			utils.SendResponse[any, any](ctx, nil, nil, http_error.UNAUTHORIZED)

provider/controller_provider.go

@@ -7,6 +7,7 @@ type ControllerProvider interface {
 	ProvideAuthController() controllers.AuthController
 	ProvideChatController() controllers.ChatController
 	ProvideAdminController() controllers.AdminController
+	ProvideSocketController() controllers.SocketController
 }
 
 type controllerProvider struct {
@@ -14,6 +15,7 @@ type controllerProvider struct {
 	authController       controllers.AuthController
 	chatController       controllers.ChatController
 	adminController      controllers.AdminController
+	socketController     controllers.SocketController
 }
 
 func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider {
@@ -22,12 +24,14 @@ func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider
 	authController := controllers.NewAuthController(servicesProvider.ProvideAuthService())
 	chatController := controllers.NewChatController(servicesProvider.ProvideChatService())
 	adminController := controllers.NewAdminController(servicesProvider.ProvideAdminService())
+	socketController := controllers.NewSocketController(servicesProvider.ProvideSocketService())
 
 	return &controllerProvider{
 		connectionController: connectionController,
 		authController:       authController,
 		chatController:       chatController,
 		adminController:      adminController,
+		socketController:     socketController,
 	}
 }
 
@@ -46,3 +50,7 @@ func (c *controllerProvider) ProvideChatController() controllers.ChatController
 func (c *controllerProvider) ProvideAdminController() controllers.AdminController {
 	return c.adminController
 }
+
+func (c *controllerProvider) ProvideSocketController() controllers.SocketController {
+	return c.socketController
+}

provider/services_provider.go

@@ -7,6 +7,7 @@ type ServicesProvider interface {
 	ProvideAuthService() services.AuthService
 	ProvideChatService() services.ChatService
 	ProvideAdminService() services.AdminService
+	ProvideSocketService() services.SocketService
 }
 
 type servicesProvider struct {
@@ -14,10 +15,12 @@ type servicesProvider struct {
 	authService       services.AuthService
 	chatService       services.ChatService
 	adminService      services.AdminService
+	socketService     services.SocketService
 }
 
 func NewServicesProvider(repoProvider RepositoriesProvider, configProvider ConfigProvider) ServicesProvider {
-	connectionService := services.NewConnectionService(repoProvider.ProvideConnectionRepository())
+	socketService := services.NewSocketService()
+	connectionService := services.NewConnectionService(repoProvider.ProvideConnectionRepository(), socketService)
 	authService := services.NewAuthService(repoProvider.ProvideAuthRepository(), repoProvider.ProvideConnectionRepository(), configProvider.ProvideJWTConfig(), configProvider.ProvideEnvConfig())
 	chatService := services.NewChatService(connectionService, repoProvider.ProvideChatRepository())
 	adminService := services.NewAdminService(repoProvider.ProvideAuthRepository(), configProvider.ProvideEnvConfig())
@@ -27,6 +30,7 @@ func NewServicesProvider(repoProvider RepositoriesProvider, configProvider Confi
 		authService:       authService,
 		chatService:       chatService,
 		adminService:      adminService,
+		socketService:     socketService,
 	}
 }
 
@@ -45,3 +49,7 @@ func (s *servicesProvider) ProvideChatService() services.ChatService {
 func (s *servicesProvider) ProvideAdminService() services.AdminService {
 	return s.adminService
 }
+
+func (s *servicesProvider) ProvideSocketService() services.SocketService {
+	return s.socketService
+}

router/router.go

@@ -16,6 +16,7 @@ func RunRouter(appProvider provider.AppProvider) {
 	AuthRouter(router, controller, middleware)
 	ChatRouter(router, controller, middleware)
 	AdminRouter(router, controller, middleware)
+	SocketRouter(router, controller, middleware)
 
 	router.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
 

router/socket_router.go

@@ -0,0 +1,19 @@
+package router
+
+import (
+	"whatsapp-backend/provider"
+
+	"github.com/gin-gonic/gin"
+)
+
+func SocketRouter(router *gin.Engine, controller provider.ControllerProvider, middleware provider.MiddlewareProvider) {
+	socketController := controller.ProvideSocketController()
+	authMiddleware := middleware.ProvideAuthMiddleware()
+
+	// WebSocket endpoint needs to be authenticated
+	routerGroup := router.Group("/api/whatsapp", authMiddleware.RequireAuth())
+	// routerGroup.Use(gzip.Gzip(gzip.DefaultCompression)) // gzip might interfere with websocket upgrade
+	{
+		routerGroup.GET("/socket", socketController.HandleWebSocket)
+	}
+}

services/connection_service.go

@@ -20,12 +20,14 @@ type ConnectionService interface {
 
 type connectionService struct {
 	connectionRepo repositories.ConnectionRepository
+	socketService  SocketService
 	activeClients  sync.Map
 }
 
-func NewConnectionService(connectionRepo repositories.ConnectionRepository) ConnectionService {
+func NewConnectionService(connectionRepo repositories.ConnectionRepository, socketService SocketService) ConnectionService {
 	return &connectionService{
 		connectionRepo: connectionRepo,
+		socketService:  socketService,
 	}
 }
 
@@ -52,6 +54,7 @@ func (s *connectionService) Connect(ctx context.Context, accountID uuid.UUID) (s
 		go func() {
 			for evt := range qrChan {
 				if evt.Event == "code" {
+					s.socketService.EmitEvent(accountID, "qr_code", evt.Code)
 					select {
 					case qrCodeChan <- evt.Code:
 					default:
@@ -95,19 +98,22 @@ func (s *connectionService) handleWhatsAppEvent(accountID uuid.UUID, client *wha
 			jid := client.Store.ID.String()
 			if s.connectionRepo.IsJIDUsedByOther(jid, accountID) {
 				log.Printf("[WhatsApp] JID conflict detected for account %s", accountID)
+				s.socketService.EmitEvent(accountID, "error", "JID conflict: This number is already connected to another account")
 				client.Disconnect()
 				s.activeClients.Delete(accountID)
 				return
 			}
 
 			_ = s.connectionRepo.UpdateAccountStatus(accountID, jid, true)
+			s.socketService.EmitEvent(accountID, "connected", map[string]string{"jid": jid})
 		}
 
 	case *events.LoggedOut:
 		s.activeClients.Delete(accountID)
 		_ = s.connectionRepo.UpdateAccountStatus(accountID, "", false)
+		s.socketService.EmitEvent(accountID, "logged_out", nil)
 
 	case *events.Disconnected:
-		// Client disconnected, status will be reflected in GetStatus endpoint
+		s.socketService.EmitEvent(accountID, "disconnected", nil)
 	}
 }

services/socket_service.go

@@ -0,0 +1,130 @@
+package services
+
+import (
+	"log"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+)
+
+type SocketService interface {
+	HandleConnection(w http.ResponseWriter, r *http.Request, userID uuid.UUID)
+	EmitEvent(userID uuid.UUID, eventType string, payload interface{})
+	BroadcastEvent(eventType string, payload interface{})
+}
+
+type socketService struct {
+	clients    map[uuid.UUID][]*websocket.Conn
+	clientsMux sync.RWMutex
+	upgrader   websocket.Upgrader
+}
+
+func NewSocketService() SocketService {
+	return &socketService{
+		clients: make(map[uuid.UUID][]*websocket.Conn),
+		upgrader: websocket.Upgrader{
+			ReadBufferSize:  1024,
+			WriteBufferSize: 1024,
+			CheckOrigin: func(r *http.Request) bool {
+				return true // Development mode
+			},
+		},
+	}
+}
+
+func (s *socketService) HandleConnection(w http.ResponseWriter, r *http.Request, userID uuid.UUID) {
+	conn, err := s.upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("Failed to upgrade connection: %v", err)
+		return
+	}
+
+	s.registerClient(userID, conn)
+	defer s.unregisterClient(userID, conn)
+
+	// Keep connection alive and listen for disconnects
+	for {
+		_, _, err := conn.ReadMessage()
+		if err != nil {
+			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
+				log.Printf("error: %v", err)
+			}
+			break
+		}
+	}
+}
+
+func (s *socketService) registerClient(userID uuid.UUID, conn *websocket.Conn) {
+	s.clientsMux.Lock()
+	defer s.clientsMux.Unlock()
+
+	s.clients[userID] = append(s.clients[userID], conn)
+	log.Printf("Client connected: %s", userID)
+}
+
+func (s *socketService) unregisterClient(userID uuid.UUID, conn *websocket.Conn) {
+	s.clientsMux.Lock()
+	defer s.clientsMux.Unlock()
+
+	conn.Close()
+
+	if conns, ok := s.clients[userID]; ok {
+		for i, c := range conns {
+			if c == conn {
+				s.clients[userID] = append(conns[:i], conns[i+1:]...)
+				break
+			}
+		}
+		if len(s.clients[userID]) == 0 {
+			delete(s.clients, userID)
+		}
+	}
+	log.Printf("Client disconnected: %s", userID)
+}
+
+func (s *socketService) EmitEvent(userID uuid.UUID, eventType string, payload interface{}) {
+	s.clientsMux.RLock()
+	conns, ok := s.clients[userID]
+	s.clientsMux.RUnlock()
+
+	if !ok {
+		return
+	}
+
+	message := map[string]interface{}{
+		"type":    eventType,
+		"payload": payload,
+		"time":    time.Now(),
+	}
+
+	for _, conn := range conns {
+		err := conn.WriteJSON(message)
+		if err != nil {
+			log.Printf("Error sending message to user %s: %v", userID, err)
+			conn.Close()
+		}
+	}
+}
+
+func (s *socketService) BroadcastEvent(eventType string, payload interface{}) {
+	s.clientsMux.RLock()
+	defer s.clientsMux.RUnlock()
+
+	message := map[string]interface{}{
+		"type":    eventType,
+		"payload": payload,
+		"time":    time.Now(),
+	}
+
+	for userID, conns := range s.clients {
+		for _, conn := range conns {
+			err := conn.WriteJSON(message)
+			if err != nil {
+				log.Printf("Error broadcasting to user %s: %v", userID, err)
+			}
+		}
+	}
+}