Add logic to send rooms to storage blob

Author: DistractedCat

backend/common/question_struct.go

@@ -17,3 +17,8 @@ type FrontendQuestion struct {
 	TopicTags  []string `json:"topicTags"`
 	Content    string   `json:"content"`
 }
+
+type MatchingQuestion struct {
+	TopicTags []string `json:"topicTags"`
+	Difficulty string `json:"difficulty"`
+}

backend/database/database_interactions.go

@@ -10,6 +10,7 @@ import (
 	"peerprep/common"
 
 	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
@@ -34,6 +35,36 @@ func (db *QuestionDB) GetAllQuestionsWithQuery(
 	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")

backend/transport/get_random_matching_question.go

@@ -0,0 +1,43 @@
+package transport
+
+import (
+	"net/http"
+	"peerprep/common"
+	"peerprep/database"
+
+	"github.com/gin-gonic/gin"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+func GetRandomMatchingQuestion(db *database.QuestionDB, logger *common.Logger) (gin.HandlerFunc) {
+	return func(ctx *gin.Context) {
+		var request common.MatchingQuestion
+
+		err := ctx.BindJSON(&request)
+
+		if err != nil {
+			ctx.JSON(http.StatusBadGateway, "error binding request from JSON")
+			logger.Log.Error("Error converting JSON to matching request:", err.Error())
+			return
+		}
+		
+		filter := bson.D{
+			{Key: "topicTags", Value: bson.D{{Key: "$in", Value: request.TopicTags}}},
+			{Key: "difficulty", Value: request.Difficulty},
+		}
+		question, err := db.GetOneQuestionWithQuery(logger, filter)
+
+		if err != nil {
+			ctx.JSON(http.StatusBadGateway, "error retrieving questions from database")
+			return
+		}
+
+		if question == nil {
+			ctx.JSON(http.StatusNotFound, "no questions found matching the request")
+			return
+		}	
+		
+		ctx.JSON(http.StatusOK, question)
+		logger.Log.Info("matching-service request handled successfully")
+	}
+}

backend/transport/question_http_requests.go

@@ -19,12 +19,13 @@ func SetAllEndpoints(router *gin.Engine, db *database.QuestionDB, logger *common
 	router.DELETE("/questions/delete/:id", DeleteQuestionWithLogger(db, logger))
 	router.PUT("/questions/replace/:id", ReplaceQuestionWithLogger(db, logger))
 	router.GET("/health", HealthCheck(logger))
+	router.POST("/match", GetRandomMatchingQuestion(db, logger))
 }
 
 // enable CORS for the frontend
 func SetCors(router *gin.Engine, origin string) {
 	router.Use(cors.New(cors.Config{
-		AllowOrigins:     []string{origin},
+		AllowOrigins:     []string{origin, "http://localhost"},
 		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
 		AllowHeaders:     []string{"Origin", "Content-Type", "Content-Length", "Authorization"},
 		ExposeHeaders:    []string{"Content-Length"},

matching-service/consumer/begin_consuming.go

@@ -26,7 +26,7 @@ func BeginConsuming(mq *models.MessageQueue, logger *models.Logger, clientMappin
 
 	go func() {
 		for req := range msgs {
-			if err := Process(req, clientMappings); err != nil {
+			if err := Process(req, clientMappings, roomMappings); err != nil {
 				logger.Log.Error("Unable to convert request from JSON:" + err.Error())
 			}
 		}

matching-service/consumer/process_request.go

@@ -7,31 +7,36 @@ package consumer
 
 import (
 	"encoding/json"
-	db "matching-service/storage"
-	"matching-service/models"
-
 	"fmt"
+	"matching-service/models"
+	db "matching-service/storage"
 
 	rabbit "github.com/streadway/amqp"
 )
 
-func Process(msg rabbit.Delivery, mappings *db.ClientMappings) error {
+func Process(msg rabbit.Delivery, clientMappings *db.ClientMappings, roomMappings *db.RoomMappings) error {
 	var request models.IncomingRequests
 
 	if err := json.Unmarshal(msg.Body, &request); err != nil {
-		return err
+		return fmt.Errorf("error unmarshling the request from JSON: %s", err.Error())
 	}
 
-	room, err := mappings.HandleRequest(request)
+	room, err := clientMappings.HandleRequest(request)
 
 	if err != nil {
-		return err
+		return fmt.Errorf("error handling incoming request: %s", err.Error())
 	}
 
+	fmt.Println("success handling incoming request!")
 	//deliver the response to the backend
 	//TODO: to implement this
 	if room != nil {
-		
+		if err := roomMappings.SendToStorageBlob(room); err != nil {
+			return err
+		}
+
+		fmt.Println("success sending to storage blob")
 	}
+
 	return nil
 }

matching-service/models/room.go

@@ -1,10 +1,19 @@
 package models
 
 type Room struct {
-	RoomId     string
-	User1      string
-	User2      string
-	TopicTags  []string
-	Difficulty string
-	RequestTime string  //takes user1's requestTime since this is older
+	
+	RoomId     string	`json:"roomId"`
+	User1      string	`json:"user1"`
+	User2      string	`json:"user2"`
+	RequestTime string	`json:"requestTime"` //takes user1's requestTime since this is older
+	
+	//contains question Data
+	Title      string   `json:"title"`
+	TitleSlug  string   `json:"titleSlug"`
+	Difficulty string   `json:"difficulty"`
+	TopicTags  []string `json:"topicTags"`
+	Content    string   `json:"content"`
+	Schemas    []string `json:"schemas"`
+	QuestionId         int      `json:"id"`
+
 }

matching-service/storage/client_mappings.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"io"
 	"matching-service/models"
+	"matching-service/transport"
 	"time"
 
 	redis "github.com/go-redis/redis/v8"
@@ -32,7 +33,7 @@ func InitialiseClientMappings(addr string, db_num int) *ClientMappings {
 
 func (db *ClientMappings) HandleRequest(request models.IncomingRequests) (*models.Room, error){
 	ctx := context.Background()
-	user2, user2_difficulty, user2_topics := request.UserId, request.Difficulty, request.TopicTags
+	user2, user2_difficulty, user2_topics, user2_requestTime := request.UserId, request.Difficulty, request.TopicTags, request.RequestTime
 
 	currMappings, err := db.Conn.Keys(ctx, "*").Result()
 
@@ -55,7 +56,8 @@ func (db *ClientMappings) HandleRequest(request models.IncomingRequests) (*model
 		}
 
 		user1_difficulty := result["difficulty"]
-
+		user1_requestTime := result["requestTime"]
+		
 		if user1_difficulty != user2_difficulty {
 			continue
 		}
@@ -67,22 +69,32 @@ func (db *ClientMappings) HandleRequest(request models.IncomingRequests) (*model
 		}	
 
 
-		if roomId, err := generateRoomId(); err != nil {
+		roomId, err := generateRoomId()
+		
+		if err != nil {
 			return nil, err
-		} else {
-			db.Conn.Del(ctx, user1)
-			
+		} 
+		
+		db.Conn.Del(ctx, user1)
 
+		room := models.Room{
+			RoomId: roomId,
+			User1: user1,
+			User2: user2,
+			RequestTime: user1_requestTime,
+		}
+
+		err = transport.FindSuitableQuestionId(overlappingTopics, user1_difficulty, &room)
 
-			return &models.Room{
-				RoomId: roomId,
-				User1: user1,
-				User2: user2,
-				TopicTags: overlappingTopics,
-				Difficulty: user1_difficulty,
-			}, nil
+		if err != nil {
+			return nil, err
+		} else if room.QuestionId == 0 {
+			//no matching question
+			continue
 		}
 
+		return &room, nil
+
 	}
 
 	//no match found
@@ -96,13 +108,14 @@ func (db *ClientMappings) HandleRequest(request models.IncomingRequests) (*model
 	err = db.Conn.HSet(ctx, user2, map[string]interface{}{
 		"topicTags": user2_topics_json,
 		"difficulty": user2_difficulty,
-	}).Err()
+		"requestTime": user2_requestTime,
+		}).Err()
 
 	if err != nil {
 		return nil, err
 	}
 
-	requestTime, err := time.Parse("2006-01-02 15-04-05", request.RequestTime)
+	requestTime, err := time.Parse("2006-01-02 15-04-05", user2_requestTime)
 
 	if err != nil {
 		return nil, err

matching-service/storage/room_mappings.go

@@ -1,6 +1,12 @@
 package storage
 
 import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"matching-service/models"
+	"time"
+
 	redis "github.com/go-redis/redis/v8"
 )
 
@@ -18,4 +24,74 @@ func InitialiseRoomMappings(addr string, db_num int) *RoomMappings {
 	return &RoomMappings{
 		Conn: conn,
 	}
+}
+
+func (db *RoomMappings) SendToStorageBlob(room *models.Room) error {
+	ctx := context.Background()
+	topics_json, err := json.Marshal(room.TopicTags)
+
+	if err != nil {
+		return fmt.Errorf("error marshling topics: %s", err.Error())
+	}
+
+	schema_json, err := json.Marshal(room.Schemas)
+
+	if err != nil {
+		return fmt.Errorf("error marshling topics: %s", err.Error())
+	}
+
+
+	user1_info := map[string]interface{}{
+		"roomId": room.RoomId,
+		"otherUser": room.User2,
+		"requestTime": room.RequestTime,
+
+		"title": room.Title,
+		"titleSlug": room.TitleSlug,
+		"difficulty": room.Difficulty,
+		"topicTags": topics_json,
+		"content": room.Content,
+		"schemas": schema_json,
+		"id": room.QuestionId,
+	}
+
+	user2_info := map[string]interface{}{
+		"roomId": room.RoomId,
+		"otherUser": room.User1,
+		"requestTime": room.RequestTime,
+
+		"title": room.Title,
+		"titleSlug": room.TitleSlug,
+		"difficulty": room.Difficulty,
+		"topicTags": topics_json,
+		"content": room.Content,
+		"schemas": schema_json,
+		"id": room.QuestionId,
+	}
+
+	
+	err = db.Conn.HSet(ctx, room.User1, user1_info, room.User2, user2_info).Err()
+
+	if err != nil {
+		return fmt.Errorf("error setting rooms to storage: %s", err.Error())
+	}
+	
+	requestTime, err := time.Parse("2006-01-02 15-04-05", room.RequestTime)
+
+	if err != nil {
+		return fmt.Errorf("error parsing the time: %s", err.Error())
+	}
+
+	expiryTime := requestTime.Add(30 * time.Second)
+	diff := int(time.Until(expiryTime).Seconds())
+	
+	if err1 := db.Conn.Expire(ctx, room.User1, time.Duration(diff) * time.Second).Err(); err1 != nil {	
+		return fmt.Errorf("error setting expiry time on room data: %s", err1.Error())
+	}
+	
+	if err2 := db.Conn.Expire(ctx, room.User2, time.Duration(diff) * time.Second).Err(); err2 != nil {
+		return fmt.Errorf("error setting expiry time on room data: %s", err2.Error())
+	}	
+		
+	return nil
 }