Merge pull request #1258 from Satyam005/feature/fetching-user-device-info-mobile-auth

`GET` route for fetching user device info for qr-code mobile auth

Author: heyrandhir

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

@@ -119,9 +119,27 @@ const updateAuthStatus = async (req, res) => {
   }
 };
 
+const fetchUserDeviceInfo = async (req, res) => {
+  try {
+    const deviceId = req.query.device_id;
+    const userDeviceInfoData = await QrCodeAuthModel.retrieveUserDeviceInfo(deviceId);
+    if (!userDeviceInfoData.userExists) {
+      return res.boom.notFound(`User with id ${deviceId} does not exist.`);
+    }
+    return res.json({
+      message: "Authentication document retrieved successfully.",
+      data: { ...userDeviceInfoData.data },
+    });
+  } catch (error) {
+    logger.error(`Error while fetching user: ${error}`);
+    return res.boom.badImplementation(SOMETHING_WENT_WRONG);
+  }
+};
+
 module.exports = {
   githubAuth,
   signout,
   storeUserDeviceInfo,
   updateAuthStatus,
+  fetchUserDeviceInfo,
 };

middlewares/validators/qrCodeAuth.js

@@ -32,7 +32,22 @@ const validateAuthStatus = async (req, res, next) => {
   }
 };
 
+const validateFetchingUserDocument = async (req, res, next) => {
+  const schema = joi.object().strict().keys({
+    device_id: joi.string().required(),
+  });
+
+  try {
+    await schema.validateAsync(req.query);
+    next();
+  } catch (error) {
+    logger.error(`Invalid Query Parameters Passed`);
+    res.boom.badRequest(`Invalid Query Parameters Passed`);
+  }
+};
+
 module.exports = {
   storeUserDeviceInfo,
   validateAuthStatus,
+  validateFetchingUserDocument,
 };

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", userDeviceInfoValidator.validateFetchingUserDocument, 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,62 @@ 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",
+        access_token: "ACCESS_TOKEN",
+      };
+    });
+    afterEach(async function () {
+      await cleanDb();
+    });
+
+    it("should successfully fetch the user device info", function (done) {
+      qrCodeAuthModel.storeUserDeviceInfo(userDeviceInfoData).then((response) => {
+        chai
+          .request(app)
+          .get(`/auth/qr-code-auth?device_id=${response.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.data.user_id).to.be.a("string");
+            expect(res.body.data.device_info).to.be.a("string");
+            expect(res.body.data.device_id).to.be.a("string");
+            expect(res.body.data.authorization_status).to.be.a("string");
+            expect(res.body.data.access_token).to.be.a("string");
+            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(`User with id ${userDeviceInfoData.device_id} does not exist.`);
+          expect(res.body.error).to.equal("Not Found");
+
+          return done();
+        });
+    });
+  });
 });

test/unit/middlewares/qrCodeAuthValidator.test.js

@@ -1,5 +1,9 @@
 const Sinon = require("sinon");
-const { validateAuthStatus, storeUserDeviceInfo } = require("../../../middlewares/validators/qrCodeAuth");
+const {
+  validateAuthStatus,
+  storeUserDeviceInfo,
+  validateFetchingUserDocument,
+} = require("../../../middlewares/validators/qrCodeAuth");
 const { expect } = require("chai");
 const { userDeviceInfoDataArray } = require("../../fixtures/qrCodeAuth/qrCodeAuth");
 describe("qrCodeAuth", function () {
@@ -65,4 +69,39 @@ describe("qrCodeAuth", function () {
       expect(nextSpy.callCount).to.be.equal(0);
     });
   });
+
+  describe("test get call validator", function () {
+    it("Allows request to pass on valid params", async function () {
+      const req = {
+        query: {
+          device_id: "DEVICE_ID",
+        },
+      };
+
+      const res = {};
+
+      const nextSpy = Sinon.spy();
+      await validateFetchingUserDocument(req, res, nextSpy);
+      expect(nextSpy.callCount).to.be.equal(1);
+    });
+
+    it("Does not allow request to pass on invalid params", async function () {
+      const req = {
+        query: {
+          user_id: "ID",
+          device_type: "DEVICE_TYPE",
+        },
+      };
+
+      const res = {
+        boom: {
+          badRequest: () => {},
+        },
+      };
+
+      const nextSpy = Sinon.spy();
+      await validateFetchingUserDocument(req, res, nextSpy);
+      expect(nextSpy.callCount).to.be.equal(0);
+    });
+  });
 });

test/unit/models/qrCodeAuth.test.js

@@ -78,4 +78,42 @@ 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",
+        access_token: "ACCESS_TOKEN",
+      };
+
+      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,
+        access_token: accessToken,
+      } = 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");
+      expect(accessToken).to.be.a("string");
+    });
+  });
 });