Add ability to store in redis

Author: DistractedCat

matching-service/consumer/begin_consuming.go

@@ -2,10 +2,10 @@ package consumer
 
 import (
 	"matching-service/models"
-	db "matching-service/mappings"
+	db "matching-service/storage"
 )
 
-func BeginConsuming(mq *models.MessageQueue, logger *models.Logger, mappings *db.Mappings) {
+func BeginConsuming(mq *models.MessageQueue, logger *models.Logger, clientMappings *db.ClientMappings, roomMappings *db.RoomMappings) {
 	logger.Log.Info("Begin processing requests")
 
 	msgs, err := mq.Channel.Consume(
@@ -26,7 +26,7 @@ func BeginConsuming(mq *models.MessageQueue, logger *models.Logger, mappings *db
 
 	go func() {
 		for req := range msgs {
-			if err := Process(req, mappings); err != nil {
+			if err := Process(req, clientMappings); err != nil {
 				logger.Log.Error("Unable to convert request from JSON:" + err.Error())
 			}
 		}

matching-service/consumer/process_request.go

@@ -7,30 +7,31 @@ package consumer
 
 import (
 	"encoding/json"
-	db "matching-service/mappings"
+	db "matching-service/storage"
 	"matching-service/models"
 
-	rabbit "github.com/streadway/amqp"
 	"fmt"
+
+	rabbit "github.com/streadway/amqp"
 )
 
-func Process(msg rabbit.Delivery, mappings *db.Mappings) error {
-	var request models.Requests
+func Process(msg rabbit.Delivery, mappings *db.ClientMappings) error {
+	var request models.IncomingRequests
 
 	if err := json.Unmarshal(msg.Body, &request); err != nil {
 		return err
 	}
 
-
 	room, err := mappings.HandleRequest(request)
 
-	fmt.Println("handled!")
 	if err != nil {
 		return err
 	}
 
 	//deliver the response to the backend
 	//TODO: to implement this
-	if room != nil {}
+	if room != nil {
+		
+	}
 	return nil
-}
+}

matching-service/main.go

@@ -4,9 +4,10 @@ import (
 	"log"
 	"os"
 
-	models "matching-service/models"
-	"matching-service/mappings"
 	"matching-service/consumer"
+	models "matching-service/models"
+	"matching-service/storage"
+
 	"github.com/joho/godotenv"
 	rabbit "github.com/streadway/amqp"
 
@@ -92,9 +93,21 @@ func main() {
 	logger, logFile := initialiseLogger()
 
 	defer logFile.Close()
-	storage := mappings.CreateMappings()
+	//TODO: remove this
+	//deprecatedStorage := mappings.CreateMappings()
+
+
+	REDIS_URI := os.Getenv("REDIS_URI")
+
+	if REDIS_URI == "" {
+		REDIS_URI = "localhost://9190"
+	}
+	
+	clientMappings := storage.InitialiseClientMappings(REDIS_URI, 0)
+	roomMappings := storage.InitialiseRoomMappings(REDIS_URI, 1)
+
 
 	logger.Log.Info("Beginning consumption from message queue")
-	consumer.BeginConsuming(mq, logger, storage)
+	consumer.BeginConsuming(mq, logger, clientMappings, roomMappings)
 
 }

matching-service/mappings/client_mappings.go

@@ -1,3 +1,4 @@
+//this file is deprecated
 package mappings
 
 import (
@@ -7,25 +8,25 @@ import (
 	"fmt"
 	"io"
 	"matching-service/models"
-
 )
 
-//TODO: consider using redis to store this information instead
+// TODO: consider using redis to store this information instead
 type Mappings struct {
-	Topics map[string][]string
+	Topics     map[string][]string
 	Difficulty map[string]string
 }
 
 func CreateMappings() *Mappings {
 	return &Mappings{
-		Topics: make(map[string][]string),
+		Topics:     make(map[string][]string),
 		Difficulty: make(map[string]string),
 	}
 }
-//TODO: implement logic to implement TTL for values
-//logic to find matching categories and generates a room id for the 2 users 
-func (db *Mappings) HandleRequest(request models.Requests) (*models.Room, error){
-	for user1, topics:= range db.Topics {
+
+// TODO: implement logic to implement TTL for values
+// logic to find matching categories and generates a room id for the 2 users
+func (db *Mappings) HandleRequest(request models.IncomingRequests) (*models.Room, error) {
+	for user1, topics := range db.Topics {
 		if difficulty, exists := db.Difficulty[user1]; !exists {
 			return nil, fmt.Errorf("user %s only exists in topics store and not in difficulty store", user1)
 		} else if difficulty != request.Difficulty {
@@ -37,8 +38,8 @@ func (db *Mappings) HandleRequest(request models.Requests) (*models.Room, error)
 		// user1 does not match with this user
 		if len(overlapping) == 0 {
 			continue
-		}		
-		
+		}
+
 		//match found, generate room Id and return the room
 		if roomId, err := generateRoomId(); err != nil {
 			return nil, err
@@ -48,20 +49,20 @@ func (db *Mappings) HandleRequest(request models.Requests) (*models.Room, error)
 			delete(db.Difficulty, user1)
 
 			return &models.Room{
-				RoomId: roomId,
-				User1: user1,
-				User2: request.UserId,
-				TopicTags: overlapping,
+				RoomId:     roomId,
+				User1:      user1,
+				User2:      request.UserId,
+				TopicTags:  overlapping,
 				Difficulty: request.Difficulty,
 			}, nil
-		} 
+		}
 	}
 
 	//no match found
 	//add user2 to the mappings
 	db.Topics[request.UserId] = request.TopicTags
 	db.Difficulty[request.UserId] = request.Difficulty
-	
+
 	return nil, nil
 }
 
@@ -76,22 +77,22 @@ func generateRoomId() (string, error) {
 }
 
 func findOverLap(user1 []string, user2 []string) []string {
-	
+
 	stringMap := make(map[string]bool)
-    var commonStrings []string
-
-    // Store each string from slice1 in the map
-    for _, topic := range user1 {
-        stringMap[topic] = true
-    }
-
-    // Iterate over slice2 and check for common strings
-    for _, topic := range user2 {
-        if stringMap[topic] {
-            commonStrings = append(commonStrings, topic)
-            delete(stringMap, topic) // Remove to avoid duplicates in result
-        }
-    }
-
-    return commonStrings	
-}
+	var commonStrings []string
+
+	// Store each string from slice1 in the map
+	for _, topic := range user1 {
+		stringMap[topic] = true
+	}
+
+	// Iterate over slice2 and check for common strings
+	for _, topic := range user2 {
+		if stringMap[topic] {
+			commonStrings = append(commonStrings, topic)
+			delete(stringMap, topic) // Remove to avoid duplicates in result
+		}
+	}
+
+	return commonStrings
+}

matching-service/models/matching_request.go

@@ -1,8 +1,13 @@
 package models
 
-type Requests struct {
-	UserId string `json:"userId"`
-	TopicTags []string `json:"topicTags"`
-	Difficulty string `json:"difficulty"`
-	RequestTime string `json:"requestTime"`
+type IncomingRequests struct {
+	UserId      string   `json:"userId"`
+	TopicTags   []string `json:"topicTags"`
+	Difficulty  string   `json:"difficulty"`
+	RequestTime string   `json:"requestTime"`
 }
+
+type OutGoingRequests struct {
+	TopicTags   []string `json:"topicTags"`
+	Difficulty  string   `json:"difficulty"`
+}

matching-service/models/question.go

@@ -0,0 +1,13 @@
+//representation of the question returned as a response
+package models
+
+
+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"`
+}