Merge branch 'main' into hist

Author: ketamethane

Backend/MatchingService/package-lock.json

@@ -1,6 +1,7 @@
 {
   "dependencies": {
     "amqplib": "^0.10.4",
+    "axios": "^1.7.7",
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
     "express": "^4.21.1",

Backend/MatchingService/package.json

@@ -1,7 +1,7 @@
 const amqp = require('amqplib');
 const { matching_exchange_name } = require('./setup.js');
 
-let channel = null;  // Store a persistent channel connection
+let channel = null;
 
 async function connectToRabbitMQ() {
     if (!channel) {
@@ -16,16 +16,15 @@ async function connectToRabbitMQ() {
     return channel;
 }
 
-async function publishToQueue({userId, difficulty, language}) {
+async function publishToQueue({ userId, difficulty, category }) {
     try {
-        const channel = await connectToRabbitMQ();  // Reuse persistent connection
-        const routingKey = `${difficulty}.${language}`;
+        const channel = await connectToRabbitMQ();
+        const routingKey = `${difficulty}.${category}`;
 
-        // Publish the message to the exchange
         const messageSent = channel.publish(
             matching_exchange_name,
             routingKey,
-            Buffer.from(JSON.stringify({ userId, difficulty, language }))
+            Buffer.from(JSON.stringify({ userId, difficulty, category }))
         );
 
         if (messageSent) {
@@ -38,26 +37,26 @@ async function publishToQueue({userId, difficulty, language}) {
     }
 }
 
-async function publishCancelRequest({ userId }) {
-    try {
-        const channel = await connectToRabbitMQ(); // Reuse persistent connection
-        const routingKey = 'cancel'; // Define a routing key for cancellation
-
-        // Publish the cancel message to the exchange
-        const messageSent = channel.publish(
-            matching_exchange_name,
-            routingKey,
-            Buffer.from(JSON.stringify({ userId }))
-        );
-
-        if (messageSent) {
-            console.log(`Cancel request sent: ${userId}`);
-        } else {
-            console.error(`Cancel request NOT sent: ${userId}`);
-        }
-    } catch (error) {
-        console.error('Error publishing cancel request to RabbitMQ:', error);
-    }
-}
-
-module.exports = { publishToQueue, publishCancelRequest }; 
+// async function publishCancelRequest({ userId }) {
+//     try {
+//         const channel = await connectToRabbitMQ();
+//         const routingKey = 'cancel';
+
+//         const messageSent = channel.publish(
+//             matching_exchange_name,
+//             routingKey,
+//             Buffer.from(JSON.stringify({ userId }))
+//         );
+
+//         if (messageSent) {
+//             console.log(`Cancel request sent: ${userId}`);
+//         } else {
+//             console.error(`Cancel request NOT sent: ${userId}`);
+//         }
+//     } catch (error) {
+//         console.error('Error publishing cancel request to RabbitMQ:', error);
+//     }
+// }
+
+// module.exports = { publishToQueue, publishCancelRequest };
+module.exports = { publishToQueue };

Backend/MatchingService/rabbitmq/publisher.js

@@ -4,16 +4,27 @@ const generator = require("../utils/generateQueues");
 const matching_exchange_name = "matching_exchange";
 const dead_letter_exchange_name = "dead_letter_exchange";
 const dead_letter_queue_name = "dead_letter_queue";
-const cancel_queue_name = "cancel_queue";
-const difficulties = ["easy", "medium", "hard"];
-const languages = ["python", "java", "cplusplus"];
-
-const queueNames = generator.generateQueueNames(
-    generator.generateCombinations(difficulties, languages)
-);
+// const cancel_queue_name = "cancel_queue";
+const difficulties = ["easy", "medium", "hard", "any"];
+const axios = require('axios');
+// Matching Service code
+const questionServiceHost = process.env.QUESTION_SERVICE_HOST || 'localhost';
+const categoryAPIUrl = `http://${questionServiceHost}:3001/api/categories`;
+
+let queueNamesPromise = axios.get(categoryAPIUrl)
+    .then(response => {
+        const categories = response.data.map(category => category.name.toLowerCase().replace(/\s+/g, '-')); 
+        console.log("categories from api: ", categories)
+        return generator.generateQueueNames(generator.generateCombinations(difficulties, categories));
+    })
+    .catch(error => {
+        console.error("Error fetching categories:", error);
+        return []; // Return an empty array if categories couldn't be fetched
+    });
 
 async function setupRabbitMQ() {
     try {
+        const queueNames = await queueNamesPromise;
         const connection = await amqp.connect(process.env.RABBITMQ_URL);
 
         if (!connection) {
@@ -30,30 +41,28 @@ async function setupRabbitMQ() {
 
         // Declare and bind all main queues with TTL and DLQ bindings
         for (let queueName of queueNames) {
-            await channel.deleteQueue(queueName);  // Ensure we start fresh for each setup
+            await channel.deleteQueue(queueName); // Ensure we start fresh for each setup
 
             await channel.assertQueue(queueName, {
                 durable: true, 
                 arguments: {
-                    'x-message-ttl': 10000,  // 60 seconds TTL
-                    'x-dead-letter-exchange': dead_letter_exchange_name  // Bind to dead-letter exchange
+                    'x-message-ttl': 10000, // TTL for messages in the queue
+                    'x-dead-letter-exchange': dead_letter_exchange_name // Bind to dead-letter exchange
                 }
             });
 
             await channel.bindQueue(queueName, matching_exchange_name, queueName); // Bind to exchange
         }
 
-        // Delete DLQ before asserting it
+        // Delete and recreate the DLQ
         await channel.deleteQueue(dead_letter_queue_name);
-
-        // Declare the dead-letter queue and bind it to the dead-letter exchange
         await channel.assertQueue(dead_letter_queue_name, { durable: true });
         await channel.bindQueue(dead_letter_queue_name, dead_letter_exchange_name, ''); // Bind with no routing key
 
-        // Declare and bind the cancel queue
-        await channel.deleteQueue(cancel_queue_name);  // Delete any existing cancel queue
-        await channel.assertQueue(cancel_queue_name, { durable: true }); // Declare the cancel queue
-        await channel.bindQueue(cancel_queue_name, matching_exchange_name, 'cancel'); // Bind with the "cancel" routing key
+        // // Delete and recreate the cancel queue
+        // await channel.deleteQueue(cancel_queue_name);
+        // await channel.assertQueue(cancel_queue_name, { durable: true });
+        // await channel.bindQueue(cancel_queue_name, matching_exchange_name, 'cancel'); // Bind with the "cancel" routing key
 
         console.log("RabbitMQ setup complete with queues, DLQ, and bindings.");
 
@@ -64,4 +73,5 @@ async function setupRabbitMQ() {
     }
 }
 
-module.exports = { setupRabbitMQ, matching_exchange_name, queueNames, dead_letter_queue_name , cancel_queue_name};
+// module.exports = { setupRabbitMQ, matching_exchange_name, queueNamesPromise, dead_letter_queue_name, cancel_queue_name };
+module.exports = { setupRabbitMQ, matching_exchange_name, queueNamesPromise, dead_letter_queue_name };