Feedback

.gitignore

@@ -0,0 +1,5 @@
+**/.env
+.idea
+*.log
+main.exe
+kubernetes

.husky/pre-commit

@@ -0,0 +1 @@
+cd ./peerprep && npx lint-staged

.lefthook.yml

@@ -0,0 +1,10 @@
+#pre-commit:
+#  parallel: true
+#  commands:
+#    golangci-lint:
+#      glob: "*.go"
+#      run: golangci-lint run {staged_files}
+#    lint-staged:
+#      root: "peerprep/"
+#      glob: "*.(ts|tsx|css|scss|md|json)"
+#      run: npx lint-staged

README.md

@@ -1,7 +1,5 @@
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/bzPrOe11)
 # CS3219 Project (PeerPrep) - AY2425S1
-## Group: Gxx
+## Group: G14
 
-### Note: 
-- You can choose to develop individual microservices within separate folders within this repository **OR** use individual repositories (all public) for each microservice. 
-- In the latter scenario, you should enable sub-modules on this GitHub classroom repository to manage the development/deployment **AND** add your mentor to the individual repositories as a collaborator. 
-- The teaching team should be given access to the repositories as we may require viewing the history of the repository in case of any disputes or disagreements. 
+View README [here](https://docs.google.com/document/d/1yadBdlLO0Mf9iY_GwbeY8kvQEzlA9_R3mVLtTnpQkVk/edit?tab=t.0)

backend/.env.example

@@ -0,0 +1,3 @@
+MONGODB_URI=mongodb+srv://<user>:<password>@<collection>.<name>.mongodb.net/?retryWrites=true&w=majority&appName=<appname>
+PORT=:9090
+CORS_ORIGIN=http://localhost:3000

backend/.gitignore

@@ -0,0 +1,2 @@
+.env
+log

backend/Dockerfile

@@ -0,0 +1,29 @@
+# syntax=docker/dockerfile:1
+
+FROM golang:1.23
+
+# Set destination for COPY
+WORKDIR /backend
+
+# Download Go modules
+# TODO: don't include the .env file in the COPY
+# TODO: multistage build
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Copy the source code. Note the slash at the end, as explained in
+# https://docs.docker.com/reference/dockerfile/#copy
+COPY . .
+
+# Build
+RUN CGO_ENABLED=0 GOOS=linux go build -o /backend/app
+
+# Optional:
+# To bind to a TCP port, runtime parameters must be supplied to the docker command.
+# But we can document in the Dockerfile what ports
+# the application is going to listen on by default.
+# https://docs.docker.com/reference/dockerfile/#expose
+EXPOSE 9090
+
+# Run
+CMD ["/backend/app"]

backend/common/logger_struct.go

@@ -0,0 +1,14 @@
+package common
+
+import (
+	"github.com/sirupsen/logrus"
+)
+
+// contains the logger
+type Logger struct {
+	Log *logrus.Logger
+}
+
+func NewLogger(logger *logrus.Logger) *Logger {
+	return &Logger{Log: logger}
+}

backend/common/question_struct.go

@@ -0,0 +1,24 @@
+// defines the JSON format of questions.
+package common
+
+type Question struct {
+	Title      string   `json:"title"`
+	TitleSlug  string   `json:"titleSlug"`
+	Difficulty string   `json:"difficulty"`
+	TopicTags  []string `json:"topicTags"`
+	Content    string   `json:"content"`
+	Schemas    []string `json:"schemas"`
+	Id         int      `json:"id"`
+}
+
+type FrontendQuestion struct {
+	Title      string   `json:"title"`
+	Difficulty string   `json:"difficulty"`
+	TopicTags  []string `json:"topicTags"`
+	Content    string   `json:"content"`
+}
+
+type MatchingQuestion struct {
+	TopicTags []string `json:"topicTags"`
+	Difficulty string `json:"difficulty"`
+}

backend/database/database_interactions.go

@@ -0,0 +1,117 @@
+// contains the database-related functions for the questions API.
+package database
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+
+	"peerprep/common"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+func (db *QuestionDB) GetAllQuestionsWithQuery(
+	logger *common.Logger,
+	filter bson.D,
+) ([]common.Question, error) {
+	questionCursor, err := db.questions.Find(context.Background(), filter)
+
+	if err != nil {
+		logger.Log.Error("Error retrieving questions: ", err.Error())
+		return nil, err
+	}
+
+	var questions []common.Question
+
+	if err = questionCursor.All(context.Background(), &questions); err != nil {
+		logger.Log.Error("Error decoding questions: ", err.Error())
+		return nil, err
+	}
+
+	return questions, nil
+}
+
+func (db *QuestionDB) GetOneQuestionWithQuery(
+	logger *common.Logger,
+	filter bson.D,
+) (*common.Question, error) {
+	// Define the aggregation pipeline with the $match and $sample stages
+	pipeline := mongo.Pipeline{
+		{{Key: "$match", Value: filter}},
+		{{Key: "$sample", Value: bson.D{{Key: "size", Value: 1}}}},
+	}
+
+	// Execute the aggregation pipeline
+	cursor, err := db.questions.Aggregate(context.Background(), pipeline)
+	if err != nil {
+		logger.Log.Error("Error retrieving questions: ", err.Error())
+		return nil, err
+	}
+
+	var questions []common.Question
+	if err = cursor.All(context.Background(), &questions); err != nil {
+		logger.Log.Error("Error decoding questions: ", err.Error())
+		return nil, err
+	}
+
+	if len(questions) == 0 {
+		return nil, nil
+	}
+
+	return &questions[0], nil
+}
+
+func (db *QuestionDB) AddQuestion(logger *common.Logger, question *common.Question) (int, error) {
+	if db.QuestionExists(question) {
+		logger.Log.Warn("Cannot add question: question already exists")
+		return http.StatusConflict, errors.New("question already exists")
+	}
+
+	if _, err := db.questions.InsertOne(context.Background(), question); err != nil {
+		logger.Log.Error("Error adding question", err.Error())
+		return http.StatusBadGateway, err
+	}
+
+	return http.StatusOK, nil
+}
+
+func (db *QuestionDB) UpsertQuestion(
+	logger *common.Logger,
+	question *common.Question,
+) (int, error) {
+
+	filter := bson.D{bson.E{Key: "id", Value: question.Id}}
+	setter := bson.M{"$set": question}
+	upsert := options.Update().SetUpsert(true)
+
+	_, err := db.questions.UpdateOne(context.Background(), filter, setter, upsert)
+
+	if err != nil {
+		logger.Log.Error("Error while upserting question", err.Error())
+		return http.StatusBadGateway, err
+	}
+
+	return http.StatusOK, nil
+}
+
+func (db *QuestionDB) DeleteQuestion(logger *common.Logger, id int) (int, error) {
+	deleteStatus, err := db.questions.DeleteOne(
+		context.Background(),
+		bson.D{bson.E{Key: "id", Value: id}},
+	)
+
+	if err != nil {
+		logger.Log.Error("Error deleting question", err.Error())
+		return http.StatusBadGateway, err
+	} else if deleteStatus.DeletedCount == 0 {
+		msg := fmt.Sprintf("Question with ID %d not found when deleting question", id)
+		logger.Log.Warn(msg)
+		return http.StatusNotFound, errors.New(msg)
+	}
+
+	return http.StatusNoContent, nil
+}

backend/database/database_util.go

@@ -0,0 +1,45 @@
+// utility functions for questions api
+package database
+
+import (
+	"context"
+	"peerprep/common"
+
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+// used to check if a question already exists in the database.
+func (db *QuestionDB) QuestionExists(question *common.Question) bool {
+	filter := bson.D{bson.E{Key: "title", Value: question.Title}}
+	err := db.questions.FindOne(context.Background(), filter).
+		Decode(&common.Question{})
+	//FindOne() returns error if no document is found
+	return err == nil
+}
+
+// used to find the next question ID to be used. Similar to SERIAL in psql.
+func (db *QuestionDB) FindNextQuestionId() int {
+	id := struct {
+		Next int `json:"next"`
+	}{}
+	filter := bson.D{}
+
+	if err := db.nextId.FindOne(context.Background(), filter).Decode(&id); err != nil {
+		return -1
+	}
+
+	return id.Next
+}
+
+// used to check if a question being replaced will cause duplicates in the database
+
+func (db *QuestionDB) QuestionExistsExceptId(question *common.Question) bool {
+	filter := bson.D{
+		bson.E{Key: "title", Value: question.Title},
+		bson.E{Key: "id", Value: bson.D{bson.E{Key: "$ne", Value: question.Id}}},
+	}
+	err := db.questions.FindOne(context.Background(), filter).
+		Decode(&common.Question{})
+	//FindOne() returns error if no document is found
+	return err == nil
+}

backend/database/initialise_database.go

@@ -0,0 +1,45 @@
+// this is used to initialise the database connection
+package database
+
+import (
+	"context"
+	"log"
+	"os"
+
+	"github.com/joho/godotenv"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+func InitialiseDB() (*mongo.Client, error) {
+	// Load environment variables
+	err := godotenv.Load(".env")
+
+	if err != nil {
+		log.Fatal("Error loading environment variables: " + err.Error())
+	}
+
+	mongoURI := os.Getenv("MONGODB_URI")
+
+	if mongoURI == "" {
+		log.Fatal("MONGODB_URI not set in environment variables")
+	}
+
+	clientOptions := options.Client().ApplyURI(mongoURI)
+
+	// Connect to MongoDB
+	server, err := mongo.Connect(context.Background(), clientOptions)
+
+	if err != nil {
+		log.Fatal("Error connecting to MongoDB" + err.Error())
+	}
+
+	// Check the connection
+	err = server.Ping(context.Background(), nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return server, nil
+}

backend/database/questionDB_struct.go

@@ -0,0 +1,20 @@
+package database
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+// QuestionDB is a struct that contains a pointer to a mongo client.
+// questions is the collection with all the questions, nextId is a single-entry collection that stores the next ID to be used.
+type QuestionDB struct {
+	questions *mongo.Collection
+	nextId    *mongo.Collection
+}
+
+// returns a pointer to an instance of the Question collection
+func NewQuestionDB(client *mongo.Client) *QuestionDB {
+
+	questionCollection := client.Database("questions").Collection("questions")
+	idCollection := client.Database("questions").Collection("counter")
+	return &QuestionDB{questions: questionCollection, nextId: idCollection}
+}