Merge branch 'master' into master

Author: Abhinav-055

internal/controllers/auth.go

@@ -7,25 +7,25 @@ import (
 
 	"github.com/CodeChefVIT/cookoff-backend/internal/db"
 	"github.com/CodeChefVIT/cookoff-backend/internal/helpers/auth"
-	helpers "github.com/CodeChefVIT/cookoff-backend/internal/helpers/auth"
 	"github.com/CodeChefVIT/cookoff-backend/internal/helpers/database"
 	httphelpers "github.com/CodeChefVIT/cookoff-backend/internal/helpers/http"
 	logger "github.com/CodeChefVIT/cookoff-backend/internal/helpers/logging"
 	"github.com/CodeChefVIT/cookoff-backend/internal/helpers/validator"
 	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	"golang.org/x/crypto/bcrypt"
 )
 
 type LoginRequest struct {
-	Email    string `json:"email" validate:"required"`
+	Email    string `json:"email"    validate:"required,email"`
 	Password string `json:"password" validate:"required"`
 }
 
 type SignupRequest struct {
-	Email string `json:"email" validate:"required"`
-	Name  string `json:"name" validate:"required"`
-	RegNo string `json:"reg_no" validate:"required"`
+	Email string `json:"email"    validate:"required"`
+	Name  string `json:"name"     validate:"required"`
+	RegNo string `json:"reg_no"   validate:"required"`
 	Key   string `json:"fuck_you" validate:"required"`
 }
 
@@ -93,32 +93,32 @@ func LoginHandler(w http.ResponseWriter, r *http.Request) {
 
 	user, err := database.Queries.GetUserByEmail(r.Context(), req.Email)
 	if err != nil {
-		logger.Errof("User not found or invalid credentials for email: %s, err: %v", req.Email, err)
-		httphelpers.WriteError(w, http.StatusUnauthorized, "invalid credentials")
+		if errors.Is(err, pgx.ErrNoRows) {
+			httphelpers.WriteError(w, http.StatusNotFound, "user not found")
+			return
+		}
+		logger.Infof("received error from database %v", err.Error())
+		httphelpers.WriteError(w, http.StatusInternalServerError, "some error occurred")
 		return
 	}
 
 	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.Password)); err != nil {
 		if errors.Is(err, bcrypt.ErrMismatchedHashAndPassword) {
-			httphelpers.WriteJSON(w, http.StatusBadRequest, map[string]string{
-				"message": "invalid password",
-			})
+			httphelpers.WriteError(w, http.StatusConflict, "invalid password")
 			return
 		}
 		httphelpers.WriteError(w, http.StatusInternalServerError, err.Error())
 	}
 
-	accessToken, err := helpers.GenerateJWT(&user, false)
+	accessToken, err := auth.GenerateJWT(&user, false)
 	if err != nil {
-		logger.Errof("Failed to generate access token for user: %s, err: %v", user.Email, err)
-		httphelpers.WriteError(w, http.StatusUnauthorized, "failed to generate token")
+		httphelpers.WriteError(w, http.StatusInternalServerError, "failed to generate token")
 		return
 	}
 
-	refreshToken, err := helpers.GenerateJWT(&user, true)
+	refreshToken, err := auth.GenerateJWT(&user, true)
 	if err != nil {
-		logger.Errof("Failed to generate refresh token for user: %s, err: %v", user.Email, err)
-		httphelpers.WriteError(w, http.StatusUnauthorized, "failed to generate token")
+		httphelpers.WriteError(w, http.StatusInternalServerError, "failed to generate token")
 		return
 	}
 
@@ -150,6 +150,6 @@ func LoginHandler(w http.ResponseWriter, r *http.Request) {
 
 	httphelpers.WriteJSON(w, http.StatusOK, map[string]any{
 		"message": "Login successful",
-		"user":    data,
+		"data":    data,
 	})
 }

internal/controllers/me.go

@@ -4,14 +4,19 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/CodeChefVIT/cookoff-backend/internal/db"
 	helpers "github.com/CodeChefVIT/cookoff-backend/internal/helpers/auth"
 	"github.com/CodeChefVIT/cookoff-backend/internal/helpers/database"
 	httphelpers "github.com/CodeChefVIT/cookoff-backend/internal/helpers/http"
 	logger "github.com/CodeChefVIT/cookoff-backend/internal/helpers/logging"
 	"github.com/google/uuid"
 )
 
+type DashboardSubmission struct {
+	Title       string `json:"title"`
+	Description string `json:"description"`
+	Score       int    `json:"score"`
+}
+
 func MeHandler(w http.ResponseWriter, r *http.Request) {
 	id, err := helpers.GetUserID(w, r)
 	if err != nil {
@@ -33,11 +38,15 @@ func MeHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var submissionsByRound = make(map[string][]db.GetSubmissionsWithRoundByUserIdRow)
+	var submissionsByRound = make(map[string][]DashboardSubmission)
 
 	for _, submission := range submissions {
 		round := fmt.Sprint(submission.Round)
-		submissionsByRound[round] = append(submissionsByRound[round], db.GetSubmissionsWithRoundByUserIdRow(submission))
+		submissionsByRound[round] = append(submissionsByRound[round], DashboardSubmission{
+			Title:       *submission.Title,
+			Description: *submission.Description,
+			Score:       0,
+		})
 	}
 
 	data := map[string]any{

internal/controllers/questions.go

@@ -37,6 +37,11 @@ type QuestionRequest struct {
 	OutputFormat *string     `json:"output_format"`
 }
 
+type QuestionByRoundResp struct {
+	Question  db.Question                    `json:"question"`
+	Testcases []db.GetTestCasesByQuestionRow `json:"testcases"`
+}
+
 func GetAllQuestion(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	fetchedQuestions, err := database.Queries.GetQuestions(ctx)
@@ -79,7 +84,22 @@ func GetQuestionsByRound(w http.ResponseWriter, r *http.Request) {
 		httphelpers.WriteError(w, http.StatusBadRequest, err.Error())
 		return
 	}
-	httphelpers.WriteJSON(w, 200, questions)
+
+	response := []QuestionByRoundResp{}
+	for _, question := range questions {
+		testcase, err := database.Queries.GetTestCasesByQuestion(ctx, question.ID)
+		if err != nil {
+			httphelpers.WriteError(w, http.StatusBadRequest, err.Error())
+			return
+		}
+		resp := QuestionByRoundResp{
+			Question:  question,
+			Testcases: testcase,
+		}
+		response = append(response, resp)
+	}
+
+	httphelpers.WriteJSON(w, 200, response)
 }
 
 func CreateQuestion(w http.ResponseWriter, r *http.Request) {

internal/controllers/refresh_token.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"errors"
 	"net/http"
 
 	helpers "github.com/CodeChefVIT/cookoff-backend/internal/helpers/auth"
@@ -9,6 +10,7 @@ import (
 	logger "github.com/CodeChefVIT/cookoff-backend/internal/helpers/logging"
 	"github.com/go-chi/jwtauth/v5"
 	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
 )
 
 func RefreshTokenHandler(w http.ResponseWriter, r *http.Request) {
@@ -42,15 +44,17 @@ func RefreshTokenHandler(w http.ResponseWriter, r *http.Request) {
 
 	user, err := database.Queries.GetUserById(r.Context(), userIdUUID)
 	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			httphelpers.WriteError(w, http.StatusUnauthorized, "user not found")
+			return
+		}
 		logger.Errof("User not found: %s, err: %v", user.Name, err)
-		httphelpers.WriteError(w, http.StatusUnauthorized, "user not found")
 		return
 	}
 
 	accessToken, err := helpers.GenerateJWT(&user, false)
 	if err != nil {
-		logger.Errof("Failed to generate new access token for user: %s, err: %v", user.Name, err)
-		httphelpers.WriteError(w, http.StatusUnauthorized, "failed to generate token")
+		httphelpers.WriteError(w, http.StatusInternalServerError, "failed to generate token")
 		return
 	}
 
@@ -66,8 +70,7 @@ func RefreshTokenHandler(w http.ResponseWriter, r *http.Request) {
 
 	refreshToken, err := helpers.GenerateJWT(&user, true)
 	if err != nil {
-		logger.Errof("Failed to generate new refresh token for user: %s, err: %v", user.Name, err)
-		httphelpers.WriteError(w, http.StatusUnauthorized, "failed to generate token")
+		httphelpers.WriteError(w, http.StatusInternalServerError, "failed to generate token")
 		return
 	}
 

internal/controllers/testcase.go

@@ -16,12 +16,12 @@ import (
 )
 
 type createTestCaseRequest struct {
-	ExpectedOutput string  `json:"expected_output" validate:"required"`
-	Memory         string  `json:"memory" validate:"required"`
-	Input          string  `json:"input" validate:"required"`
-	Hidden         *bool   `json:"hidden" validate:"required"`
-	QuestionID     string  `json:"question_id" validate:"required"`
-	Runtime        float64 `json:"runtime" validate:"required"`
+	ExpectedOutput string  `json:"expected_output" validate:"required,omitempty"`
+	Memory         string  `json:"memory"          validate:"required,omitempty"`
+	Input          string  `json:"input"           validate:"required,omitempty"`
+	Hidden         *bool   `json:"hidden"          validate:"required,omitempty"`
+	QuestionID     string  `json:"question_id"     validate:"required,omitempty"`
+	Runtime        float64 `json:"runtime,string"  validate:"required,omitempty"`
 }
 
 func CreateTestCaseHandler(w http.ResponseWriter, r *http.Request) {
@@ -40,7 +40,7 @@ func CreateTestCaseHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var newTestCase = db.CreateTestCaseParams{
+	newTestCase := db.CreateTestCaseParams{
 		ExpectedOutput: testCase.ExpectedOutput,
 		Memory:         testCase.Memory,
 		Input:          testCase.Input,
@@ -114,7 +114,7 @@ func UpdateTestCaseHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var updateData = db.UpdateTestCaseParams{
+	updateData := db.UpdateTestCaseParams{
 		ExpectedOutput: originalTestCase.ExpectedOutput,
 		Memory:         originalTestCase.Memory,
 		Input:          originalTestCase.Input,
@@ -153,7 +153,11 @@ func UpdateTestCaseHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	httphelpers.WriteJSON(w, http.StatusOK, map[string]string{"message": "Test case updated successfully"})
+	httphelpers.WriteJSON(
+		w,
+		http.StatusOK,
+		map[string]string{"message": "Test case updated successfully"},
+	)
 }
 
 func DeleteTestCaseHandler(w http.ResponseWriter, r *http.Request) {
@@ -194,5 +198,4 @@ func GetTestCaseByQuestionID(w http.ResponseWriter, r *http.Request) {
 		"message": "fetched testcases",
 		"data":    testCases,
 	})
-
 }

internal/helpers/auth/verify_role.go

@@ -1,28 +1,20 @@
 package auth
 
 import (
-	"fmt"
 	"net/http"
 
 	httphelpers "github.com/CodeChefVIT/cookoff-backend/internal/helpers/http"
 	"github.com/go-chi/jwtauth/v5"
 )
 
-func RoleFromToken (w http.ResponseWriter,r *http.Request, user string) bool {
+func RoleFromToken(w http.ResponseWriter, r *http.Request, requiredRole string) bool {
 	_, claims, err := jwtauth.FromContext(r.Context())
 	if err != nil {
 		httphelpers.WriteError(w, http.StatusUnauthorized, err.Error())
 		return false
 	}
-	role, ok := claims["role"].(string)
-	if !ok {
-		http.Error(w, "Role not found in token", http.StatusUnauthorized)
-		return ok
-	}
-	if role != user {
-		msg := fmt.Sprintf("Access Denied: %s not allowed", role)
-		httphelpers.WriteError(w,  http.StatusForbidden, msg)
-		return false
-	}
-	return true
-}
+	role := claims["role"].(string)
+
+	return role != requiredRole
+}
+

internal/server/routes.go

@@ -26,6 +26,7 @@ func (s *Server) RegisterRoutes(taskClient *asynq.Client) http.Handler {
 
 	r.Post("/login/user", controllers.LoginHandler)
 	r.Post("/token/refresh", controllers.RefreshTokenHandler)
+
 	r.Group(func(protected chi.Router) {
 		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Post("/upgrade", controllers.UpgradeUserToRound)
 		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Post("/roast", controllers.BanUser)
@@ -37,14 +38,18 @@ func (s *Server) RegisterRoutes(taskClient *asynq.Client) http.Handler {
 
 		protected.Get("/me", controllers.MeHandler)
 		protected.Get("/protected", controllers.ProtectedHandler)
-		protected.With(middlewares.BanCheckMiddleware).Post("/submit", controllers.SubmitCode)
-        protected.With(middlewares.BanCheckMiddleware).Post("/runcode", controllers.RunCode)
-		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Post("/question/create", controllers.CreateQuestion)
-		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Get("/questions", controllers.GetAllQuestion)
-		protected.With(middlewares.BanCheckMiddleware).Get("/question/round", controllers.GetQuestionsByRound)
-		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Get("/question/{question_id}", controllers.GetQuestionById)
-		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Delete("/question/{question_id}", controllers.DeleteQuestion)
-		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Patch("/question", controllers.UpdateQuestion)
+
+    protected.With(middlewares.BanCheckMiddleware).Post("/submit", controllers.SubmitCode)
+    protected.With(middlewares.BanCheckMiddleware).Post("/runcode", controllers.RunCode)
+    protected.With(middlewares.BanCheckMiddleware).Get("/question/round", controllers.GetQuestionsByRound)
+
+		adminRoutes := protected.With(middlewares.RoleAuthorizationMiddleware("admin"))
+
+		adminRoutes.Post("/question/create", controllers.CreateQuestion)
+		adminRoutes.Get("/questions", controllers.GetAllQuestion)
+		adminRoutes.Get("/question/{question_id}", controllers.GetQuestionById)
+		adminRoutes.Delete("/question/{question_id}", controllers.DeleteQuestion)
+		adminRoutes.Patch("/question", controllers.UpdateQuestion)
 	})
 
 	r.Group(func(protected chi.Router) {

internal/worker/submissionWorker.go

@@ -10,6 +10,7 @@ import (
 	"github.com/CodeChefVIT/cookoff-backend/internal/controllers"
 	"github.com/CodeChefVIT/cookoff-backend/internal/db"
 	"github.com/CodeChefVIT/cookoff-backend/internal/helpers/database"
+	logger "github.com/CodeChefVIT/cookoff-backend/internal/helpers/logging"
 	"github.com/CodeChefVIT/cookoff-backend/internal/helpers/submission"
 	"github.com/google/uuid"
 	"github.com/hibiken/asynq"
@@ -20,9 +21,8 @@ const TypeProcessSubmission = "submission:process"
 
 func ProcessSubmissionTask(ctx context.Context, t *asynq.Task) error {
 	var data controllers.Data
-	log.Print("Processing task: ", t.Type)
-	log.Println("Payload: ", string(t.Payload()))
-	log.Println(data)
+	logger.Infof("Processing task: %v", t.Type)
+	logger.Infof("Payload: %v", string(t.Payload()))
 
 	if err := json.Unmarshal(t.Payload(), &data); err != nil {
 		log.Printf("Error unmarshalling task payload: %v\n", err)