Implemented real-time online debate platform with structured phases and AI judgment using WebSocket and WebRTC

backend/cmd/server/main.go

@@ -2,57 +2,91 @@ package main
 
 import (
 	"log"
+	"os"
 	"strconv"
 
 	"arguehub/config"
+	"arguehub/db"
+	"arguehub/middlewares"
 	"arguehub/routes"
+	"arguehub/services"
+	"arguehub/utils"
 	"arguehub/websocket"
 
 	"github.com/gin-contrib/cors"
 	"github.com/gin-gonic/gin"
 )
 
 func main() {
+	// Load the configuration from the specified YAML file
 	cfg, err := config.LoadConfig("./config/config.prod.yml")
 	if err != nil {
 		log.Fatalf("Failed to load config: %v", err)
 	}
 
-	router := setupRouter(cfg)
+	services.InitDebateVsBotService(cfg)
+	// Connect to MongoDB using the URI from the configuration
+	if err := db.ConnectMongoDB(cfg.Database.URI); err != nil {
+		log.Fatalf("Failed to connect to MongoDB: %v", err)
+	}
+	log.Println("Connected to MongoDB")
+
+	// Seed initial debate-related data
+	utils.SeedDebateData()
+	utils.PopulateTestUsers()
+
+	// Create uploads directory
+	os.MkdirAll("uploads", os.ModePerm)
 
+	// Set up the Gin router and configure routes
+	router := setupRouter(cfg)
 	port := strconv.Itoa(cfg.Server.Port)
 	log.Printf("Server starting on port %s", port)
+
 	if err := router.Run(":" + port); err != nil {
 		log.Fatalf("Failed to start server: %v", err)
 	}
 }
 
 func setupRouter(cfg *config.Config) *gin.Engine {
-	// gin.SetMode(gin.ReleaseMode) // Uncomment this line for production
-
 	router := gin.Default()
+
+	// Set trusted proxies (adjust as needed)
 	router.SetTrustedProxies([]string{"127.0.0.1", "localhost"})
 
+	// Configure CORS for your frontend (e.g., localhost:5173 for Vite)
 	router.Use(cors.New(cors.Config{
 		AllowOrigins:     []string{"http://localhost:5173"},
 		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
 		AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
 		ExposeHeaders:    []string{"Content-Length"},
 		AllowCredentials: true,
 	}))
+	router.OPTIONS("/*path", func(c *gin.Context) { c.Status(204) })
 
-	router.OPTIONS("/*path", func(c *gin.Context) {
-		c.Status(204)
-	})
-
+	// Public routes for authentication
 	router.POST("/signup", routes.SignUpRouteHandler)
 	router.POST("/verifyEmail", routes.VerifyEmailRouteHandler)
 	router.POST("/login", routes.LoginRouteHandler)
 	router.POST("/forgotPassword", routes.ForgotPasswordRouteHandler)
 	router.POST("/confirmForgotPassword", routes.VerifyForgotPasswordRouteHandler)
 	router.POST("/verifyToken", routes.VerifyTokenRouteHandler)
-
-	router.GET("/ws", websocket.WebsocketHandler)
+
+	// Protected routes (JWT auth)
+	auth := router.Group("/")
+	auth.Use(middlewares.AuthMiddleware("./config/config.prod.yml"))
+	{
+		auth.GET("/user/fetchprofile", routes.GetProfileRouteHandler)
+		auth.PUT("/user/updateprofile", routes.UpdateProfileRouteHandler)
+		auth.GET("/leaderboard", routes.GetLeaderboardRouteHandler)
+		auth.POST("/debate/result", routes.UpdateEloAfterDebateRouteHandler)
+		routes.SetupDebateVsBotRoutes(auth)
+
+		// WebSocket signaling endpoint
+		auth.GET("/ws", websocket.WebsocketHandler)
+
+		routes.SetupTranscriptRoutes(auth)
+	}
 
 	return router
-}
+}

backend/config/config.go

@@ -2,37 +2,47 @@ package config
 
 import (
 	"fmt"
-    "io/ioutil"
+	"io/ioutil"
 
-    "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
 )
+
 type Config struct {
-    Server struct {
-        Port int `yaml:"port"`
-    } `yaml:"server"`
-
-    Cognito struct {
-        AppClientId     string `yaml:"appClientId"`
-        AppClientSecret string `yaml:"appClientSecret"`
-        UserPoolId      string `yaml:"userPoolId"`
-        Region          string `yaml:"region"`
-    } `yaml:"cognito"`
-
-    Openai struct {
-        GptApiKey       string `yaml:"gptApiKey"`
-    } `yaml:"openai`
+	Server struct {
+		Port int `yaml:"port"`
+	} `yaml:"server"`
+
+	Cognito struct {
+		AppClientId     string `yaml:"appClientId"`
+		AppClientSecret string `yaml:"appClientSecret"`
+		UserPoolId      string `yaml:"userPoolId"`
+		Region          string `yaml:"region"`
+	} `yaml:"cognito"`
+
+	Openai struct {
+		GptApiKey string `yaml:"gptApiKey"`
+	} `yaml:"openai"`
+
+	Gemini struct {
+		ApiKey string `yaml:"apiKey"`
+	} `yaml:"gemini"`
+
+	Database struct {
+		URI string `yaml:"uri"`
+	} `yaml:"database"`
 }
 
+// LoadConfig reads the configuration file
 func LoadConfig(path string) (*Config, error) {
-    data, err := ioutil.ReadFile(path)
-    if err != nil {
-        return nil, fmt.Errorf("failed to read config file: %w", err)
-    }
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config file: %w", err)
+	}
 
-    var cfg Config
-    if err := yaml.Unmarshal(data, &cfg); err != nil {
-        return nil, fmt.Errorf("failed to unmarshal yaml: %w", err)
-    }
+	var cfg Config
+	if err := yaml.Unmarshal(data, &cfg); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal yaml: %w", err)
+	}
 
-    return &cfg, nil
+	return &cfg, nil
 }

backend/config/config.prod.yml

@@ -1,12 +1,17 @@
 server:
-  port: 1313
+ port: 1313
 
 cognito:
-  appClientId: 
-  appClientSecret: 
-  userPoolId:
-  region:
+  appClientId: <your-cognito-app-client-id>
+  appClientSecret: <your-cognito-app-client-secret>
+  userPoolId: <your-cognito-user-pool-id>
+  region: eu-north-1
 
 openai:
-  gptApiKey: 
-
+  gptApiKey: <your-openai-gpt-api-key>
+
+database:
+  uri: "<your-mongodb-connection-string>"
+
+gemini:
+  apiKey: "<your-gemini-api-key>"