Fix bugs.

Author: laihuiqi

peer-prep/src/matching-service/services/matchingService.js

@@ -4,7 +4,7 @@ const { v4: uuidv4 } = require('uuid');
 const { addMatchedPair, getCurrentMatchedPair } = require('../database/matchedPairDb');
 const MatchedPair = require('../models/matchedPairModel');
 
-const refreshDuration = 3000; // 5 seconds
+const refreshDuration = 3000; // 3 seconds
 const waitingDuration = 3000;
 const matchingDuration = 60000 - waitingDuration;
 const queueName = 'matchingQueue';
@@ -18,26 +18,32 @@ async function findMatch(request) {
         let connection;
         let channel;
         let checkCancel;
+
         try {
             connection = await amqp.connect(config.rabbitmqUrl);
             channel = await connection.createChannel();
+
             console.log('Successfully connected to RabbitMQ');
 
-            const criteria = `${request.language}.${request.proficiency}.${request.difficulty}.${request.topic}`;
+            const criteria = `${request.language}
+                            .${request.proficiency}
+                            .${request.difficulty}
+                            .${request.topic}`;
 
             checkCancel = setInterval(async() => {
                 if (isCancelled.has(parseInt(request.id))) {
-                    console.log(`Always checking`);
                     clearInterval(checkCancel);
                     resolve({ isMatched: false, collaboratorId: null, request: request });
 
                 } else {
                     const checkMatchedPair = await getCurrentMatchedPair(request.id);
+
                     if (checkMatchedPair) {
                         clearInterval(checkCancel);
                         resolve({
                             isMatched: true,
-                            collaboratorId: String(checkMatchedPair.id1) === String(request.id) ? parseInt(checkMatchedPair.id2) : parseInt(checkMatchedPair.id1),
+                            collaboratorId: String(checkMatchedPair.id1) === String(request.id) ?
+                                parseInt(checkMatchedPair.id2) : parseInt(checkMatchedPair.id1),
                             request: request
                         });
                     }
@@ -46,18 +52,25 @@ async function findMatch(request) {
 
             await addRequestIntoQueue(channel, criteria, request);
 
-            await new Promise(resolve => setTimeout(resolve, 5000)); // wait for 5 seconds to check if there is a prior object that matched
+            await new Promise(resolve => setTimeout(resolve, waitingDuration));
+            // wait for 5 seconds to check if there is a prior object that matched
 
-            const { stored, isMatched, id, collaboratorId } = await getMatchFromQueue(channel, criteria, request);
+            const { stored, isMatched, id, collaboratorId } =
+            await getMatchFromQueue(channel, criteria, request);
 
             console.log(`Clean up tasks are completed for ${request.id}!`);
 
             if (!isMatched) {
                 console.log(`Matched pair could not be found for ${request.id}`);
+
                 resolve({ isMatched: false, collaboratorId: null, request: request });
 
             } else if (stored) {
-                resolve({ isMatched: true, collaboratorId: parseInt(collaboratorId), request: request });
+                resolve({
+                    isMatched: true,
+                    collaboratorId: parseInt(collaboratorId),
+                    request: request
+                });
 
             } else if (isMatched && !stored) {
                 const matchedPair = new MatchedPair({
@@ -69,17 +82,21 @@ async function findMatch(request) {
                     proficiency: request.proficiency,
                     difficulty: request.difficulty,
                     topic: request.topic
-
                 });
 
                 await addMatchedPair(matchedPair);
 
-                resolve({ isMatched: true, collaboratorId: parseInt(collaboratorId), request: request });
+                resolve({
+                    isMatched: true,
+                    collaboratorId: parseInt(collaboratorId),
+                    request: request
+                });
             }
         } catch (error) {
             console.log('Error finding match: ', error);
         } finally {
             availabilityCache.delete(request.id);
+
             if (channel) {
                 channel.close();
             }
@@ -111,10 +128,13 @@ async function addRequestIntoQueue(channel, criteria, request) {
 // Check if there exists a matched pair for the user, else, find a match from the queue
 async function getMatchFromQueue(channel, criteria, request) {
     console.log(`Checking if there is a match for user ${request.id} and find match from queue...`);
+
     const currentPair = await getCurrentMatchedPair(request.id);
 
     if (currentPair) {
-        const collaboratorId = String(currentPair.id1) === String(request.id) ? currentPair.id2 : currentPair.id1;
+        const collaboratorId =
+            String(currentPair.id1) === String(request.id) ? currentPair.id2 : currentPair.id1;
+
         return { stored: true, isMatched: true, id: request.id, collaboratorId: collaboratorId };
 
     } else {
@@ -126,13 +146,19 @@ async function getMatchFromQueue(channel, criteria, request) {
 async function listenToMatchingQueue(channel, criteria, request) {
     try {
         console.log(`Start matching user ${request.id}`);
+
         await channel.assertQueue(queueName, { durable: false });
 
         let matched = false;
         return new Promise(async(resolve) => {
             setTimeout(() => {
                 if (!matched) {
-                    resolve({ stored: false, isMatched: false, id: request.id, collaboratorId: null });
+                    resolve({
+                        stored: false,
+                        isMatched: false,
+                        id: request.id,
+                        collaboratorId: null
+                    });
                 }
             }, matchingDuration);
 
@@ -143,27 +169,46 @@ async function listenToMatchingQueue(channel, criteria, request) {
                 const checkActivePair = await getCurrentMatchedPair(currentRequest.request.id);
 
                 if (checkActivePair &&
-                    (String(checkActivePair.id1) === String(request.id) || String(checkActivePair.id2) === String(request.id))) {
-                    resolve({ stored: true, isMatched: true, id: request.id, collaboratorId: currentRequest.request.id });
+                    (String(checkActivePair.id1) === String(request.id) ||
+                        String(checkActivePair.id2) === String(request.id))) {
+
+                    resolve({
+                        stored: true,
+                        isMatched: true,
+                        id: request.id,
+                        collaboratorId: currentRequest.request.id
+                    });
+
+                } else if (checkActivePair ||
+                    isCancelled.has(parseInt(currentRequest.request.id))) {
 
-                } else if (checkActivePair || isCancelled.has(parseInt(currentRequest.request.id))) {
                     console.log(`Remove match ${currentRequest.request.id}`);
+
                     availabilityCache.delete(currentRequest.request.id);
                     channel.ack(message);
 
-                } else if (!matched && currentRequest.request.id !== request.id &&
-                    currentRequest.criteria === criteria && availabilityCache.has(currentRequest.request.id)) {
+                } else if (!matched &&
+                    currentRequest.request.id !== request.id &&
+                    currentRequest.criteria === criteria &&
+                    availabilityCache.has(currentRequest.request.id)) {
+
                     console.log(`Found a match for ${request.id}`);
 
                     channel.ack(message);
                     availabilityCache.delete(currentRequest.request.id);
                     availabilityCache.delete(request.id);
-                    console.log(`${request.id} has been matched with ${currentRequest.request.id}`);
+                    console.log(`${request.id} has been matched with
+                                 ${currentRequest.request.id}`);
 
                     matched = true;
                     console.log(`Successfully matched user ${request.id}`);
 
-                    resolve({ stored: false, isMatched: matched, id: request.id, collaboratorId: currentRequest.request.id });
+                    resolve({
+                        stored: false,
+                        isMatched: matched,
+                        id: request.id,
+                        collaboratorId: currentRequest.request.id
+                    });
                 }
             });
         });
@@ -177,7 +222,9 @@ async function listenToMatchingQueue(channel, criteria, request) {
 async function cancelMatch(requestId) {
     isCancelled.add(parseInt(requestId));
     availabilityCache.delete(requestId);
+
     console.log(`Matching service is cancelled for ${requestId}`);
+
     return true;
 }