Merge pull request #31 from vaibhavsijaria/main

Running code on visible test cases without creating submission

Author: RustyDev24

internal/controllers/runcode.go

@@ -0,0 +1,88 @@
+package controllers
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/url"
+
+	"github.com/CodeChefVIT/cookoff-backend/internal/db"
+	"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/submission"
+	"github.com/google/uuid"
+)
+
+type resp struct {
+	Result []submission.Judgeresp `json:"result"`
+}
+
+func RunCode(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	var req subreq
+	err := json.NewDecoder(r.Body).Decode(&req)
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusBadRequest, "Invalid request payload")
+		return
+	}
+
+	question_id, _ := uuid.Parse(req.QuestionID)
+
+	testcases, err := database.Queries.GetTestCases(ctx, db.GetTestCasesParams{QuestionID: question_id, Column2: true})
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusBadRequest, "Question not found")
+		return
+	}
+
+	judge0URL, _ := url.Parse(JUDGE0_URI + "/submissions/")
+	params := url.Values{}
+	params.Add("base64_encoded", "true")
+	params.Add("wait", "true")
+	judge0URL.RawQuery = params.Encode()
+
+	var payload submission.Submission
+	response := resp{
+		Result: make([]submission.Judgeresp, len(testcases)),
+	}
+	for i, testcase := range testcases {
+		payload = submission.Submission{
+			LanguageID: req.LanguageID,
+			SourceCode: submission.B64(req.SourceCode),
+			Input:      submission.B64(*testcase.Input),
+			Output:     submission.B64(*testcase.ExpectedOutput),
+		}
+
+		payloadJSON, err := json.Marshal(payload)
+		if err != nil {
+			logger.Errof("Error marshaling payload: %v", err)
+			httphelpers.WriteError(w, http.StatusInternalServerError, "Unable to marshal payload")
+			return
+		}
+
+		result, err := http.Post(judge0URL.String(), "application/json", bytes.NewBuffer(payloadJSON))
+		if err != nil {
+			logger.Errof("Error making request to Judge0: %v", err)
+			httphelpers.WriteError(w, http.StatusInternalServerError, "Error making request to Judge0")
+			return
+		}
+		defer result.Body.Close()
+
+		var data submission.Judgeresp
+		data.TestCaseID = testcase.ID.String()
+		if err = json.NewDecoder(result.Body).Decode(&data); err != nil {
+			logger.Errof("Error decoding response from Judge0: %v", err)
+			httphelpers.WriteError(w, http.StatusInternalServerError, "Error decoding response from Judge0")
+			return
+		}
+
+		data.CompilerOutput, _ = submission.DecodeB64(data.CompilerOutput)
+		response.Result[i] = data
+	}
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		logger.Errof("Error encoding response: %v", err)
+		httphelpers.WriteError(w, http.StatusInternalServerError, "Error encoding response")
+	}
+}

internal/controllers/submission.go

@@ -4,13 +4,15 @@ import (
 	"bytes"
 	"encoding/json"
 	"net/http"
+	"net/url"
 	"os"
 
 	"github.com/CodeChefVIT/cookoff-backend/internal/db"
 	"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/submission"
+	"github.com/go-chi/jwtauth/v5"
 	"github.com/google/uuid"
 )
 
@@ -20,8 +22,9 @@ type subreq struct {
 	QuestionID string `json:"question_id"`
 }
 
+var JUDGE0_URI = os.Getenv("JUDGE0_URI")
+
 func SubmitCode(w http.ResponseWriter, r *http.Request) {
-	JUDGE0_URI := os.Getenv("JUDGE0_URI")
 	ctx := r.Context()
 
 	var req subreq
@@ -47,8 +50,12 @@ func SubmitCode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	judge0URL := JUDGE0_URI + "/submissions/batch?base64_encoded=true"
-	resp, err := http.Post(judge0URL, "application/json", bytes.NewBuffer(payload))
+	judge0URL, _ := url.Parse(JUDGE0_URI + "/submissions/batch")
+
+	params := url.Values{}
+	params.Add("base64_encoded", "true")
+	judge0URL.RawQuery = params.Encode()
+	resp, err := http.Post(judge0URL.String(), "application/json", bytes.NewBuffer(payload))
 	if err != nil {
 		logger.Errof("Error sending request to Judge0: %v", err)
 		httphelpers.WriteError(w, http.StatusInternalServerError, "Failed to send request to Judge0")
@@ -63,7 +70,13 @@ func SubmitCode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	user_id, _ := r.Context().Value("user_id").(string)
+	_, claims, err := jwtauth.FromContext(r.Context())
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+
+	user_id, _ := claims["user_id"].(string)
 	userID, _ := uuid.Parse(user_id)
 	qID, _ := uuid.Parse(req.QuestionID)
 	nullUserID := uuid.NullUUID{UUID: userID, Valid: true}

internal/helpers/submission/common.go

@@ -0,0 +1,43 @@
+package submission
+
+import (
+	"encoding/base64"
+	"encoding/json"
+)
+
+type Submission struct {
+	LanguageID int    `json:"language_id"`
+	SourceCode string `json:"source_code"`
+	Input      string `json:"stdin"`
+	Output     string `json:"expected_output"`
+	Callback   string `json:"callback_url"`
+}
+
+type Judgeresp struct {
+	TestCaseID     string
+	StdOut         string `json:"stdout"`
+	Time           string `json:"time"`
+	Memory         int    `json:"memory"`
+	StdErr         string `json:"stderr"`
+	Token          string `json:"token"`
+	Message        string `json:"message"`
+	Status         Status `json:"status"`
+	CompilerOutput string `json:"compile_output"`
+}
+
+type Status struct {
+	ID          json.Number `json:"id"`
+	Description string      `json:"description"`
+}
+
+func B64(data string) string {
+	return base64.StdEncoding.EncodeToString([]byte(data))
+}
+
+func DecodeB64(encoded string) (string, error) {
+	decodedBytes, err := base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		return "", err
+	}
+	return string(decodedBytes), nil
+}

internal/helpers/submission/submission.go

@@ -2,7 +2,6 @@ package submission
 
 import (
 	"context"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"net/http"
@@ -14,14 +13,6 @@ import (
 	"github.com/google/uuid"
 )
 
-type Submission struct {
-	LanguageID int    `json:"language_id"`
-	SourceCode string `json:"source_code"`
-	Input      string `json:"stdin"`
-	Output     string `json:"expected_output"`
-	Callback   string `json:"callback_url"`
-}
-
 type Token struct {
 	Token string `json:"token"`
 }
@@ -44,10 +35,10 @@ func CreateSubmission(ctx context.Context, question_id uuid.UUID, language_id in
 
 	for i, testcase := range testcases {
 		payload.Submissions[i] = Submission{
-			SourceCode: b64(source),
+			SourceCode: B64(source),
 			LanguageID: language_id,
-			Input:      b64(*testcase.Input),
-			Output:     b64(*testcase.ExpectedOutput),
+			Input:      B64(*testcase.Input),
+			Output:     B64(*testcase.ExpectedOutput),
 			Callback:   callback_url,
 		}
 	}
@@ -83,7 +74,3 @@ func GetSubID(ctx context.Context, token string) (string, error) {
 	}
 	return subID, nil
 }
-
-func b64(data string) string {
-	return base64.StdEncoding.EncodeToString([]byte(data))
-}

internal/server/routes.go

@@ -17,7 +17,6 @@ func (s *Server) RegisterRoutes(taskClient *asynq.Client) http.Handler {
 	r.Use(middleware.Logger)
 
 	r.Get("/ping", controllers.HealthCheck)
-	r.Post("/submit", controllers.SubmitCode)
 	r.Put("/callback", func(w http.ResponseWriter, r *http.Request) {
 		controllers.CallbackUrl(w, r, taskClient)
 	})
@@ -29,6 +28,8 @@ func (s *Server) RegisterRoutes(taskClient *asynq.Client) http.Handler {
 		protected.Use(jwtauth.Authenticator(auth.TokenAuth))
 
 		protected.Get("/protected", controllers.ProtectedHandler)
+		protected.Post("/submit", controllers.SubmitCode)
+		protected.Post("/runcode", controllers.RunCode)
 		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Post("/question/create", controllers.CreateQuestion)
 		protected.With(middlewares.RoleAuthorizationMiddleware("admin")).Get("/questions", controllers.GetAllQuestion)
 		protected.Get("/question/round", controllers.GetQuestionsByRound)