Added get route for fetching user device info

Author: Satyam005

constants/errorMessages.js

@@ -6,5 +6,6 @@ module.exports = {
   DATA_ADDED_SUCCESSFULLY: "User Device Info added successfully!",
   USER_DATA_ALREADY_PRESENT: "The authentication document has already been created",
   BAD_REQUEST: "BAD_REQUEST",
+  INVALID_QUERY_PARAM: "Invalid Query Parameters Passed",
   FILE_TOO_LARGE: (size) => `File too large, max accepted size is ${size} MB`,
 };

controllers/auth.js

@@ -2,7 +2,12 @@ const passport = require("passport");
 const users = require("../models/users");
 const QrCodeAuthModel = require("../models/qrCodeAuth");
 const authService = require("../services/authService");
-const { SOMETHING_WENT_WRONG, DATA_ADDED_SUCCESSFULLY, BAD_REQUEST } = require("../constants/errorMessages");
+const {
+  SOMETHING_WENT_WRONG,
+  DATA_ADDED_SUCCESSFULLY,
+  BAD_REQUEST,
+  INVALID_QUERY_PARAM,
+} = require("../constants/errorMessages");
 
 /**
  * Fetches the user info from GitHub and authenticates User
@@ -122,9 +127,32 @@ const updateAuthStatus = async (req, res) => {
   }
 };
 
+const fetchUserDeviceInfo = async (req, res) => {
+  try {
+    const queryParamArray = Object.keys(req.query);
+    if (queryParamArray.length === 1 && queryParamArray[0] === "device_id") {
+      const deviceId = req.query.device_id;
+      const userDeviceInfoData = await QrCodeAuthModel.retrieveUserDeviceInfo(deviceId);
+      if (!userDeviceInfoData.userExists) {
+        return res.boom.notFound("No Authentication found!");
+      }
+      return res.json({
+        message: "Authentication document retrieved successfully.",
+        data: { ...userDeviceInfoData.data },
+      });
+    } else {
+      return res.boom.badRequest(INVALID_QUERY_PARAM);
+    }
+  } catch (error) {
+    logger.error(`Error while fetching user: ${error}`);
+    return res.boom.badImplementation(SOMETHING_WENT_WRONG);
+  }
+};
+
 module.exports = {
   githubAuth,
   signout,
   storeUserDeviceInfo,
   updateAuthStatus,
+  fetchUserDeviceInfo,
 };

models/levels.js

@@ -27,7 +27,6 @@ const addLevel = async (levelData) => {
 const deleteLevel = async (id) => {
   try {
     await levelModel.doc(id).delete();
-    return;
   } catch (err) {
     logger.error("Error in deleting Level", err);
     throw err;

models/qrCodeAuth.js

@@ -54,7 +54,28 @@ const storeUserDeviceInfo = async (userDeviceInfoData) => {
   }
 };
 
+const retrieveUserDeviceInfo = async (deviceId) => {
+  try {
+    const queryDocument = await QrCodeAuthModel.where("device_id", "==", deviceId).get();
+    const userData = queryDocument.docs[0];
+
+    if (!userData) {
+      return {
+        userExists: false,
+      };
+    }
+    return {
+      userExists: true,
+      data: userData.data(),
+    };
+  } catch (err) {
+    logger.error("Error in retrieving user device info", err);
+    throw err;
+  }
+};
+
 module.exports = {
   updateStatus,
   storeUserDeviceInfo,
+  retrieveUserDeviceInfo,
 };

routes/auth.js

@@ -12,7 +12,10 @@ router.get("/github/callback", auth.githubAuth);
 
 router.get("/signout", auth.signout);
 
+router.get("/qr-code-auth", auth.fetchUserDeviceInfo);
+
 router.post("/qr-code-auth", userDeviceInfoValidator.storeUserDeviceInfo, auth.storeUserDeviceInfo);
+
 router.patch(
   "/qr-code-auth/authorization_status/:authorization_status",
   authenticate,

test/integration/qrCodeAuth.test.js

@@ -160,4 +160,51 @@ describe("QrCodeAuth", function () {
         });
     });
   });
+
+  describe("GET call for fetching user device info", function () {
+    let userId = "";
+    let userDeviceInfoData;
+    beforeEach(async function () {
+      userId = await addUser(user);
+      userDeviceInfoData = { ...userDeviceInfoDataArray[0], user_id: userId, authorization_status: "NOT_INIT" };
+    });
+    afterEach(async function () {
+      await cleanDb();
+    });
+
+    it("should successfully fetch the user device info", function (done) {
+      qrCodeAuthModel.storeUserDeviceInfo(userDeviceInfoData);
+      chai
+        .request(app)
+        .get(`/auth/qr-code-auth?device_id=${userDeviceInfoData.device_id}`)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+          expect(res).to.have.status(200);
+          expect(res.body).to.be.a("object");
+          expect(res.body.message).to.equal(`Authentication document retrieved successfully.`);
+
+          return done();
+        });
+    });
+
+    it("should fail with 404, when the document is not found", function (done) {
+      chai
+        .request(app)
+        .get(`/auth/qr-code-auth?device_id=${userDeviceInfoData.device_id}`)
+        .end((err, res) => {
+          if (err) {
+            return done(err);
+          }
+
+          expect(res).to.have.status(404);
+          expect(res.body).to.be.a("object");
+          expect(res.body.message).to.equal("No Authentication found!");
+          expect(res.body.error).to.equal("Not Found");
+
+          return done();
+        });
+    });
+  });
 });

test/unit/models/qrCodeAuth.test.js

@@ -78,4 +78,40 @@ describe("mobile auth", function () {
       expect(response.userExists).to.be.equal(false);
     });
   });
+
+  describe("retrieveUserDeviceInfo", function () {
+    it("should fetch the user device info for mobile auth", async function () {
+      const userData = userDataArray[0];
+      const { userId } = await users.addOrUpdate(userData);
+
+      const userDeviceInfoData = {
+        ...userDeviceInfoDataArray[0],
+        user_id: userId,
+        authorization_status: "NOT_INIT",
+      };
+
+      await qrCodeAuth.storeUserDeviceInfo(userDeviceInfoData);
+      const response = await qrCodeAuth.retrieveUserDeviceInfo(userDeviceInfoData.device_id);
+
+      const userDeviceInfo = response.data;
+      const {
+        user_id: userID,
+        device_info: deviceInfo,
+        device_id: deviceId,
+        authorization_status: authorizationStatus,
+      } = userDeviceInfo;
+
+      const data = (await qrCodeAuthModel.doc(userId).get()).data();
+
+      Object.keys(userDeviceInfo).forEach((key) => {
+        expect(userDeviceInfo[key]).to.deep.equal(data[key]);
+      });
+
+      expect(response).to.be.an("object");
+      expect(userID).to.be.a("string");
+      expect(deviceInfo).to.be.a("string");
+      expect(deviceId).to.be.a("string");
+      expect(authorizationStatus).to.be.a("string");
+    });
+  });
 });