Merge pull request #39 from vaibhavsijaria/main

Runtime Multipliers

Author: RustyDev24

database/schema.sql

@@ -44,7 +44,7 @@ CREATE TABLE testcases (
 	memory TEXT,
 	input TEXT,
 	hidden BOOLEAN,
-	runtime TIME,
+	runtime DECIMAL,
 	question_id UUID NOT NULL,
 	PRIMARY KEY(id)
 );

internal/controllers/runcode.go

@@ -3,6 +3,7 @@ package controllers
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/url"
 
@@ -44,11 +45,15 @@ func RunCode(w http.ResponseWriter, r *http.Request) {
 
 	testcases, err := database.Queries.GetTestCases(ctx, db.GetTestCasesParams{QuestionID: question_id, Column2: true})
 	if err != nil {
-		httphelpers.WriteError(w, http.StatusBadRequest, "Question not found")
+		httphelpers.WriteError(w, http.StatusBadRequest, fmt.Sprintf("error getting test cases for question_id %d: %v", question_id, err))
 		return
 	}
 
-	judge0URL, _ := url.Parse(JUDGE0_URI + "/submissions/")
+	judge0URL, err := url.Parse(JUDGE0_URI + "/submissions/")
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error parsing Judge0 URL: %v", err))
+		return
+	}
 	params := url.Values{}
 	params.Add("base64_encoded", "true")
 	params.Add("wait", "true")
@@ -58,25 +63,33 @@ func RunCode(w http.ResponseWriter, r *http.Request) {
 	response := resp{
 		Result: make([]submission.Judgeresp, len(testcases)),
 	}
+
+	runtime_mut, err := submission.RuntimeMut(req.LanguageID)
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
 	for i, testcase := range testcases {
+		runtime, _ := testcase.Runtime.Float64Value()
 		payload = submission.Submission{
 			LanguageID: req.LanguageID,
 			SourceCode: submission.B64(req.SourceCode),
 			Input:      submission.B64(*testcase.Input),
 			Output:     submission.B64(*testcase.ExpectedOutput),
+			Runtime:    runtime.Float64 * float64(runtime_mut),
 		}
 
 		payloadJSON, err := json.Marshal(payload)
 		if err != nil {
-			logger.Errof("Error marshaling payload: %v", err)
-			httphelpers.WriteError(w, http.StatusInternalServerError, "Unable to marshal payload")
+			httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("error marshaling payload: %v", err))
 			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")
+			logger.Errof("Error sending request to Judge0: %v", err)
+			httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error sending request to Judge0: %v", err))
 			return
 		}
 		defer result.Body.Close()
@@ -85,7 +98,7 @@ func RunCode(w http.ResponseWriter, r *http.Request) {
 		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")
+			httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error decoding response from Judge0: %v", err))
 			return
 		}
 
@@ -95,6 +108,6 @@ func RunCode(w http.ResponseWriter, r *http.Request) {
 	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")
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error encoding response: %v", err))
 	}
 }

internal/controllers/submission.go

@@ -3,6 +3,7 @@ package controllers
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/url"
 	"os"
@@ -34,65 +35,71 @@ func SubmitCode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	question_id, _ := uuid.Parse(req.QuestionID)
+	userID, _ := auth.GetUserID(w, r)
+	nullUserID := uuid.NullUUID{UUID: userID, Valid: true}
+
+	question_id, err := uuid.Parse(req.QuestionID)
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusBadRequest, "Invalid question id, unable to parse it to uuid")
+		return
+	}
+
+	qualified, err := auth.VerifyRound(ctx, userID, question_id)
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusNotFound, err.Error())
+		return
+	}
+	if !qualified {
+		httphelpers.WriteError(w, http.StatusForbidden, "User is not qualified for this round")
+		return
+	}
 
 	payload, err := submission.CreateSubmission(ctx, question_id, req.LanguageID, req.SourceCode)
 	if err != nil {
-		logger.Errof("Error creating submission: %v", err)
-		httphelpers.WriteError(w, http.StatusInternalServerError, "Failed to create submission")
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to create submission payload: %v", err))
 		return
 	}
 
 	subID, err := uuid.NewV7()
 	if err != nil {
 		logger.Errof("Error in generating uuid for submission: %v", err)
-		httphelpers.WriteError(w, http.StatusInternalServerError, "Error in generating uuid for submission")
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error in generating uuid for submission: %v", err))
 		return
 	}
 
-	judge0URL, _ := url.Parse(JUDGE0_URI + "/submissions/batch")
+	judge0URL, err := url.Parse(JUDGE0_URI + "/submissions/batch")
+	if err != nil {
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error parsing Judge0 URL: %v", err))
+		return
+	}
 
 	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")
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error sending request to Judge0: %v", err))
 		return
 	}
 	defer resp.Body.Close()
 
 	err = submission.StoreTokens(ctx, subID, resp)
 	if err != nil {
 		logger.Errof("Error storing tokens for submission ID %s: %v", subID, err)
-		httphelpers.WriteError(w, http.StatusInternalServerError, "Error storing tokens for the submission")
-		return
-	}
-
-	userID, _ := auth.GetUserID(w, r)
-	qID, _ := uuid.Parse(req.QuestionID)
-	nullUserID := uuid.NullUUID{UUID: userID, Valid: true}
-
-	qualified, err := auth.VerifyRound(ctx, userID, qID)
-	if err != nil {
-		httphelpers.WriteError(w, http.StatusNotFound, err.Error())
-		return
-	}
-	if !qualified {
-		httphelpers.WriteError(w, http.StatusForbidden, "User is not qualified for this round")
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error storing tokens for submission ID %s: %v", subID, err))
 		return
 	}
 
 	err = database.Queries.CreateSubmission(ctx, db.CreateSubmissionParams{
 		ID:         subID,
 		UserID:     nullUserID,
-		QuestionID: qID,
+		QuestionID: question_id,
 		LanguageID: int32(req.LanguageID),
 	})
 	if err != nil {
 		logger.Errof("Error creating submission in database: %v", err)
-		httphelpers.WriteError(w, http.StatusInternalServerError, "Error creating submission in database")
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error creating submission in database: %v", err))
 		return
 	}
 
@@ -103,5 +110,8 @@ func SubmitCode(w http.ResponseWriter, r *http.Request) {
 		SubmissionID: subID.String(),
 	}
 	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(respData)
+	if err := json.NewEncoder(w).Encode(respData); err != nil {
+		httphelpers.WriteError(w, http.StatusInternalServerError, fmt.Sprintf("Error encoding response: %v", err))
+		return
+	}
 }

internal/db/models.go

@@ -2,6 +2,7 @@ package auth
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 
 	"github.com/CodeChefVIT/cookoff-backend/internal/helpers/database"
@@ -13,19 +14,19 @@ import (
 func GetUserID(w http.ResponseWriter, r *http.Request) (uuid.UUID, error) {
 	_, claims, err := jwtauth.FromContext(r.Context())
 	if err != nil {
-		httphelpers.WriteError(w, http.StatusUnauthorized, "unauthorized")
+		httphelpers.WriteError(w, http.StatusUnauthorized, fmt.Sprintf("unauthorized: %v", err))
 		return uuid.UUID{}, err
 	}
 
 	userID, ok := claims["user_id"].(string)
 	if !ok {
-		httphelpers.WriteError(w, http.StatusUnauthorized, "unauthorized")
-		return uuid.UUID{}, err
+		httphelpers.WriteError(w, http.StatusUnauthorized, "unauthorized: user_id not found in claims")
+		return uuid.UUID{}, fmt.Errorf("user_id not found in claims")
 	}
 
 	userUUID, err := uuid.Parse(userID)
 	if err != nil {
-		httphelpers.WriteError(w, http.StatusUnauthorized, "unauthorized")
+		httphelpers.WriteError(w, http.StatusUnauthorized, fmt.Sprintf("unauthorized: %v", err))
 		return uuid.UUID{}, err
 	}
 

internal/helpers/auth/utils.go

@@ -3,14 +3,16 @@ package submission
 import (
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 )
 
 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"`
+	LanguageID int     `json:"language_id"`
+	SourceCode string  `json:"source_code"`
+	Input      string  `json:"stdin"`
+	Output     string  `json:"expected_output"`
+	Runtime    float64 `json:"cpu_time_limit"`
+	Callback   string  `json:"callback_url"`
 }
 
 type Judgeresp struct {
@@ -41,3 +43,20 @@ func DecodeB64(encoded string) (string, error) {
 	}
 	return string(decodedBytes), nil
 }
+
+func RuntimeMut(language_id int) (int, error) {
+	var runtime_mut int
+	switch language_id {
+	case 50, 54, 60, 73, 63:
+		runtime_mut = 1
+	case 51, 62:
+		runtime_mut = 2
+	case 68:
+		runtime_mut = 3
+	case 71:
+		runtime_mut = 5
+	default:
+		return 0, fmt.Errorf("invalid language ID: %d", language_id)
+	}
+	return runtime_mut, nil
+}

internal/helpers/submission/common.go

@@ -3,13 +3,12 @@ package submission
 import (
 	"context"
 	"encoding/json"
-	"errors"
+	"fmt"
 	"net/http"
 	"os"
 
 	"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/google/uuid"
 )
 
@@ -26,26 +25,31 @@ func CreateSubmission(ctx context.Context, question_id uuid.UUID, language_id in
 
 	testcases, err := database.Queries.GetTestCases(ctx, db.GetTestCasesParams{QuestionID: question_id, Column2: false})
 	if err != nil {
-		logger.Errof("Error getting test cases for question_id %d: %v", question_id, err)
-		return nil, err
+		return nil, fmt.Errorf("error getting test cases for question_id %d: %v", question_id, err)
 	}
 	payload := Payload{
 		Submissions: make([]Submission, len(testcases)),
 	}
 
+	runtime_mut, err := RuntimeMut(language_id)
+	if err != nil {
+		return nil, err
+	}
+
 	for i, testcase := range testcases {
+		runtime, _ := testcase.Runtime.Float64Value()
 		payload.Submissions[i] = Submission{
 			SourceCode: B64(source),
 			LanguageID: language_id,
 			Input:      B64(*testcase.Input),
 			Output:     B64(*testcase.ExpectedOutput),
+			Runtime:    runtime.Float64 * float64(runtime_mut),
 			Callback:   callback_url,
 		}
 	}
 	payloadJSON, err := json.Marshal(payload)
 	if err != nil {
-		logger.Errof("Error marshaling payload: %v", err)
-		return nil, err
+		return nil, fmt.Errorf("error marshaling payload: %v", err)
 	}
 
 	return payloadJSON, nil
@@ -55,13 +59,13 @@ func StoreTokens(ctx context.Context, subID uuid.UUID, r *http.Response) error {
 	var tokens []Token
 	err := json.NewDecoder(r.Body).Decode(&tokens)
 	if err != nil {
-		return errors.New("Invalid request payload")
+		return fmt.Errorf("Invalid request payload")
 	}
 
 	for _, t := range tokens {
 		err := Tokens.AddToken(ctx, t.Token, subID.String())
 		if err != nil {
-			return errors.New("Failed to add token")
+			return fmt.Errorf("Failed to add token")
 		}
 	}
 	return nil