feature: Adding Login by Google logic

controllers/auth_controller.go

@@ -17,6 +17,7 @@ type AuthController interface {
 	LoginUser(ctx *gin.Context)
 	LoginAdmin(ctx *gin.Context)
 	LoginWorker(ctx *gin.Context)
+	GoogleAuth(ctx *gin.Context)
 	GetProfile(ctx *gin.Context)
 	GetAllUsers(ctx *gin.Context)
 	GetAllWorkers(ctx *gin.Context)
@@ -214,3 +215,28 @@ func (c *authController) GetAllWorkers(ctx *gin.Context) {
 
 	utils.SendSuccessResponse(ctx, "Workers retrieved", workers)
 }
+
+// @Summary Google Authentication
+// @Description Authenticate with Google ID token and get JWT
+// @Tags Auth
+// @Accept json
+// @Produce json
+// @Param request body dto.GoogleAuthRequest true "Google Auth Request"
+// @Success 200 {object} dto.GoogleAuthResponse
+// @Failure 401 {object} map[string]string
+// @Router /api/auth/google [post]
+func (c *authController) GoogleAuth(ctx *gin.Context) {
+	var req dto.GoogleAuthRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	response, err := c.authService.GoogleAuth(req)
+	if err != nil {
+		utils.SendErrorResponse(ctx, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	utils.SendSuccessResponse(ctx, "Authentication successful", response)
+}

controllers/report_controller.go

@@ -34,7 +34,7 @@ func NewReportController(reportService services.ReportService) ReportController
 // @Security BearerAuth
 // @Success 200 {object} dto.ReportResponse
 // @Failure 400 {object} map[string]string
-// @Router /api/report [post]
+// @Router /api/user/report [post]
 func (c *reportController) CreateReport(ctx *gin.Context) {
 	userIDVal, exists := ctx.Get("user_id")
 	if !exists {

models/dto/google_auth_dto.go

@@ -0,0 +1,16 @@
+package dto
+
+type GoogleAuthRequest struct {
+	IDToken string `json:"idToken" binding:"required"`
+}
+
+type GoogleAuthResponse struct {
+	Token string            `json:"token"`
+	User  GoogleUserDetails `json:"user"`
+}
+
+type GoogleUserDetails struct {
+	Email     string `json:"email"`
+	Fullname  string `json:"fullname"`
+	IsNewUser bool   `json:"isNewUser"`
+}

provider/controller_provider.go

@@ -3,32 +3,24 @@ package provider
 import "dinacom-11.0-backend/controllers"
 
 type ControllerProvider interface {
-	ProvideConnectionController() controllers.ConnectionController
 	ProvideAuthController() controllers.AuthController
 	ProvideReportController() controllers.ReportController
 }
 
 type controllerProvider struct {
-	connectionController controllers.ConnectionController
-	authController       controllers.AuthController
-	reportController     controllers.ReportController
+	authController   controllers.AuthController
+	reportController controllers.ReportController
 }
 
 func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider {
-	connectionController := controllers.NewConnectionController(servicesProvider.ProvideConnectionService())
 	authController := controllers.NewAuthController(servicesProvider.ProvideAuthService())
 	reportController := controllers.NewReportController(servicesProvider.ProvideReportService())
 	return &controllerProvider{
-		connectionController: connectionController,
-		authController:       authController,
-		reportController:     reportController,
+		authController:   authController,
+		reportController: reportController,
 	}
 }
 
-func (c *controllerProvider) ProvideConnectionController() controllers.ConnectionController {
-	return c.connectionController
-}
-
 func (c *controllerProvider) ProvideAuthController() controllers.AuthController {
 	return c.authController
 }

provider/repositories_provider.go

@@ -3,32 +3,24 @@ package provider
 import "dinacom-11.0-backend/repositories"
 
 type RepositoriesProvider interface {
-	ProvideConnectionRepository() repositories.ConnectionRepository
 	ProvideUserRepository() repositories.UserRepository
 	ProvideReportRepository() repositories.ReportRepository
 }
 
 type repositoriesProvider struct {
-	connectionRepository repositories.ConnectionRepository
-	userRepository       repositories.UserRepository
-	reportRepository     repositories.ReportRepository
+	userRepository   repositories.UserRepository
+	reportRepository repositories.ReportRepository
 }
 
 func NewRepositoriesProvider(cfg ConfigProvider) RepositoriesProvider {
-	connectionRepository := repositories.NewConnectionRepository(cfg.ProvideDatabaseConfig().GetInstance())
 	userRepository := repositories.NewUserRepository(cfg.ProvideDatabaseConfig().GetInstance())
 	reportRepository := repositories.NewReportRepository(cfg.ProvideDatabaseConfig().GetInstance())
 	return &repositoriesProvider{
-		connectionRepository: connectionRepository,
-		userRepository:       userRepository,
-		reportRepository:     reportRepository,
+		userRepository:   userRepository,
+		reportRepository: reportRepository,
 	}
 }
 
-func (rp *repositoriesProvider) ProvideConnectionRepository() repositories.ConnectionRepository {
-	return rp.connectionRepository
-}
-
 func (rp *repositoriesProvider) ProvideUserRepository() repositories.UserRepository {
 	return rp.userRepository
 }

provider/services_provider.go

@@ -3,32 +3,24 @@ package provider
 import "dinacom-11.0-backend/services"
 
 type ServicesProvider interface {
-	ProvideConnectionService() services.ConnectionService
 	ProvideAuthService() services.AuthService
 	ProvideReportService() services.ReportService
 }
 
 type servicesProvider struct {
-	connectionService services.ConnectionService
-	authService       services.AuthService
-	reportService     services.ReportService
+	authService   services.AuthService
+	reportService services.ReportService
 }
 
 func NewServicesProvider(repoProvider RepositoriesProvider, configProvider ConfigProvider) ServicesProvider {
-	connectionService := services.NewConnectionService(repoProvider.ProvideConnectionRepository())
 	authService := services.NewAuthService(repoProvider.ProvideUserRepository())
 	reportService := services.NewReportService(repoProvider.ProvideReportRepository())
 	return &servicesProvider{
-		connectionService: connectionService,
-		authService:       authService,
-		reportService:     reportService,
+		authService:   authService,
+		reportService: reportService,
 	}
 }
 
-func (s *servicesProvider) ProvideConnectionService() services.ConnectionService {
-	return s.connectionService
-}
-
 func (s *servicesProvider) ProvideAuthService() services.AuthService {
 	return s.authService
 }

router/auth_router.go

@@ -29,6 +29,8 @@ func (r *authRouter) Setup(router *gin.RouterGroup) {
 	userGroup.POST("/verify-otp", r.authController.VerifyOTP)
 	userGroup.POST("/login", r.authController.LoginUser)
 
+	authGroup.POST("/google", r.authController.GoogleAuth)
+
 	adminGroup := authGroup.Group("/admin")
 	adminGroup.POST("/login", r.authController.LoginAdmin)
 

router/connection_router.go

@@ -1,17 +0,0 @@
-package router
-
-import (
-	"dinacom-11.0-backend/provider"
-	"github.com/gin-contrib/gzip"
-	"github.com/gin-gonic/gin"
-)
-
-func ConnectionRouter(router *gin.Engine, controller provider.ControllerProvider) {
-	connectionController := controller.ProvideConnectionController()
-	routerGroup := router.Group("/api")
-	routerGroup.Use(gzip.Gzip(gzip.DefaultCompression))
-	{
-		routerGroup.POST("/connect", connectionController.Connect)
-	}
-
-}

router/report_router.go

@@ -20,7 +20,7 @@ func NewReportRouter(reportController controllers.ReportController) ReportRouter
 }
 
 func (r *reportRouter) Setup(router *gin.RouterGroup) {
-	reportGroup := router.Group("/report")
+	reportGroup := router.Group("/user/report")
 	reportGroup.Use(middleware.AuthMiddleware())
 	reportGroup.POST("", r.reportController.CreateReport)
 }

router/router.go

@@ -3,13 +3,13 @@ package router
 import (
 	_ "dinacom-11.0-backend/docs"
 	"dinacom-11.0-backend/provider"
+
 	swaggerFiles "github.com/swaggo/files"
 	ginSwagger "github.com/swaggo/gin-swagger"
 )
 
 func RunRouter(appProvider provider.AppProvider) {
 	router, controller, config := appProvider.ProvideRouter(), appProvider.ProvideControllers(), appProvider.ProvideConfig()
-	ConnectionRouter(router, controller)
 
 	authRouter := NewAuthRouter(controller.ProvideAuthController())
 	authRouter.Setup(router.Group("/api"))

services/auth_service.go

@@ -18,6 +18,7 @@ type AuthService interface {
 	LoginUser(req dto.LoginRequest) (string, error)
 	LoginAdmin(req dto.LoginRequest) (string, error)
 	LoginWorker(req dto.LoginRequest) (string, error)
+	GoogleAuth(req dto.GoogleAuthRequest) (*dto.GoogleAuthResponse, error)
 	GetProfile(userID uuid.UUID) (*dto.UserResponse, error)
 	GetAllUsers() ([]dto.UserResponse, error)
 	GetAllWorkers() ([]dto.UserResponse, error)
@@ -221,3 +222,43 @@ func (s *authService) GetAllWorkers() ([]dto.UserResponse, error) {
 	}
 	return response, nil
 }
+
+func (s *authService) GoogleAuth(req dto.GoogleAuthRequest) (*dto.GoogleAuthResponse, error) {
+	tokenInfo, err := utils.VerifyGoogleToken(req.IDToken)
+	if err != nil {
+		return nil, errors.New("invalid Google token")
+	}
+
+	existingUser, _ := s.userRepo.FindUserByEmail(tokenInfo.Email)
+	isNewUser := false
+
+	if existingUser == nil {
+		isNewUser = true
+		newUser := &entity.User{
+			Username: tokenInfo.Email,
+			Fullname: tokenInfo.Name,
+			Email:    tokenInfo.Email,
+			Role:     "user",
+			Password: "",
+			Verified: true,
+		}
+		if err := s.userRepo.CreateUser(newUser); err != nil {
+			return nil, err
+		}
+		existingUser, _ = s.userRepo.FindUserByEmail(tokenInfo.Email)
+	}
+
+	token, err := utils.GenerateAccessToken(existingUser.ID, existingUser.Role, existingUser.Email)
+	if err != nil {
+		return nil, err
+	}
+
+	return &dto.GoogleAuthResponse{
+		Token: token,
+		User: dto.GoogleUserDetails{
+			Email:     existingUser.Email,
+			Fullname:  existingUser.Fullname,
+			IsNewUser: isNewUser,
+		},
+	}, nil
+}

utils/google_auth_util.go

@@ -0,0 +1,40 @@
+package utils
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+type GoogleTokenInfo struct {
+	Email         string `json:"email"`
+	EmailVerified string `json:"email_verified"`
+	Name          string `json:"name"`
+	Picture       string `json:"picture"`
+	Sub           string `json:"sub"`
+}
+
+func VerifyGoogleToken(idToken string) (*GoogleTokenInfo, error) {
+	resp, err := http.Get(fmt.Sprintf("https://oauth2.googleapis.com/tokeninfo?id_token=%s", idToken))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("invalid token")
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var tokenInfo GoogleTokenInfo
+	if err := json.Unmarshal(body, &tokenInfo); err != nil {
+		return nil, err
+	}
+
+	return &tokenInfo, nil
+}