feat: existing user can sign in with sso

apps/OpenSignServer/cloud/parsefunction/SendMailOTPv1.js

@@ -39,7 +39,7 @@ async function sendMailOTPv1(request) {
             code +
             '</p></div> </div> </div></body></html>',
         });
-        console.log('OTP sent');
+        console.log('OTP sent', code);
         if (request.params?.docId) {
           const extUserId = await getDocument(request.params?.docId);
           if (extUserId) {

apps/OpenSignServer/cloud/parsefunction/UserGroups.js

@@ -2,41 +2,41 @@
 
 //-- Export Modules
 import dotenv from 'dotenv';
-dotenv.config()
-import axios from "axios";
+dotenv.config();
+import axios from 'axios';
 
 export async function getUserGroups(request) {
   try {
     var appname = request.params.appname;
-    if (appname == "") {
-      return Promise.reject("Error:please provide appname");
+    if (appname == '') {
+      return Promise.reject('Error:please provide appname');
     }
     var response = {};
     var rolelist = {};
-    appname = appname + "_";
+    appname = appname + '_';
     //--function to get the userid from session token
     function getuserid(request) {
       return new Promise(function (resolve, reject) {
         const options = {
-          url: process.env.SERVER_URL + "/users/me",
-          method: "get",
+          url: process.env.SERVER_URL + '/users/me',
+          method: 'get',
           headers: {
-            "X-Parse-Application-Id": process.env.APP_ID,
-            "X-Parse-Session-Token": request.headers["sessiontoken"],
+            'X-Parse-Application-Id': process.env.APP_ID,
+            'X-Parse-Session-Token': request.headers['sessiontoken'],
           },
         };
 
         axios(options)
-          .then((x) => {
+          .then(x => {
             const body = x.data;
-            var error = body == "" ? true : false;
+            var error = body == '' ? true : false;
             if (error) {
-              reject("result not found!");
+              reject('result not found!');
             } else {
               resolve(body);
             }
           })
-          .catch((err) => {
+          .catch(err => {
             if (err) {
               console.error(err);
               return;
@@ -46,7 +46,7 @@ export async function getUserGroups(request) {
     }
     var userData = await getuserid(request);
     var userid = userData.objectId;
-    console.log("userid " + userid);
+    // console.log("userid " + userid);
     var url =
       process.env.SERVER_URL +
       '/roles?where={"users":{"__type":"Pointer","className":"_User","objectId":"' +
@@ -60,29 +60,29 @@ export async function getUserGroups(request) {
       return new Promise(function (resolve, reject) {
         const options = {
           url: url,
-          method: "get",
+          method: 'get',
           headers: {
-            "X-Parse-Application-Id": process.env.APP_ID,
+            'X-Parse-Application-Id': process.env.APP_ID,
           },
         };
 
         axios(options)
-          .then((x) => {
+          .then(x => {
             const body = x.data;
             var roleres = [];
-            for (var i = 0; i < body["results"].length; i++) {
-              var rolename = body["results"][i]["name"];
+            for (var i = 0; i < body['results'].length; i++) {
+              var rolename = body['results'][i]['name'];
               //var roleprefix = rolename.split("_")[0];
               roleres.push(rolename);
             }
-            var error = roleres == "" ? true : false;
+            var error = roleres == '' ? true : false;
             if (error) {
-              reject("result not found!");
+              reject('result not found!');
             } else {
               resolve(roleres);
             }
           })
-          .catch((err) => {
+          .catch(err => {
             if (err) {
               console.error(err);
               return;
@@ -92,7 +92,7 @@ export async function getUserGroups(request) {
     }
 
     rolelist = await getRoleList(request);
-    console.log(rolelist);
+    // console.log(rolelist);
     //--check user roles according to appId
     var rolesInapp = [];
     for (let i = 0; i < rolelist.length; i++) {
@@ -102,11 +102,11 @@ export async function getUserGroups(request) {
         rolesInapp.push(rolelist[i]);
       }
     }
-    console.log(rolesInapp);
+    // console.log(rolesInapp);
     return rolesInapp;
   } catch (err) {
-    console.log("err in usergroup");
+    console.log('err in usergroup');
     console.log(err);
-    return Promise.reject("Error:Result not found");
+    return Promise.reject('Error:Result not found');
   }
 }

apps/OpenSignServer/cloud/parsefunction/ssoSignin.js

@@ -0,0 +1,115 @@
+import axios from 'axios';
+
+const serverUrl = process.env.SERVER_URL;
+const APPID = process.env.APP_ID;
+const masterKEY = process.env.MASTER_KEY;
+
+/**
+ * ssoSign is function which is used to sign up/sign in with SSO
+ * @param code It is code return by jackson using authorize endpoint
+ * @param email It is user's email with user sign in/sign up
+ * @returns if success {email, message, sessiontoken} else on reject {message}
+ */
+
+export default async function ssoSignin(request) {
+  const code = request.params.code;
+  const userEmail = request.params.email;
+
+  //   console.log('code ', code);
+  try {
+    const headers = { 'content-type': 'application/x-www-form-urlencoded' };
+    const axiosRes = await axios.post(
+      'https://osl-jacksonv2.vercel.app/api/oauth/token',
+      {
+        grant_type: 'authorization_code',
+        client_id: 'dummy',
+        tenant: 'Okta-dev-nxglabs-in',
+        product: 'OpenSign',
+        client_secret: 'dummy',
+        redirect_uri: 'http://localhost:3000/sso',
+        code: code,
+      },
+      { headers: headers }
+    );
+    const ssoAccessToken = axiosRes.data && axiosRes.data.access_token;
+    // console.log('ssoAccessToken ', ssoAccessToken);
+    const authData = { sso: { id: userEmail, access_token: ssoAccessToken } };
+    const userQuery = new Parse.Query(Parse.User);
+    userQuery.equalTo('email', userEmail);
+    const res = await userQuery.first({ useMasterKey: true });
+    if (res) {
+      try {
+        const SignIn = await axios.put(
+          serverUrl + '/users/' + res.id,
+          { authData: authData },
+          {
+            headers: {
+              'X-Parse-Application-Id': APPID,
+              'X-Parse-Master-key': masterKEY,
+            },
+          }
+        );
+
+        if (SignIn.data) {
+          const sessiontoken = SignIn.data.sessionToken;
+          //   console.log('sso sessiontoken', sessiontoken);
+          return {
+            email: userEmail,
+            message: 'User Sign In',
+            sessiontoken: sessiontoken,
+          };
+        }
+      } catch (err) {
+        console.log('err in user sso sign in', err);
+        throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Internal server error.');
+      }
+    } else {
+      // console.log("in sign up condition");
+      const response = await axios.get('https://osl-jacksonv2.vercel.app/api/oauth/userinfo', {
+        headers: {
+          Authorization: `Bearer ${ssoAccessToken}`,
+        },
+      });
+      if (response.data && response.data.id) {
+        try {
+          const SignUp = await axios.post(
+            serverUrl + '/users',
+            {
+              authData: authData,
+              username: response.data.email,
+              email: response.data.email,
+              phone: response.data?.phone,
+              name: response.data?.firstName + response.data?.lastName,
+            },
+            {
+              headers: {
+                'X-Parse-Application-Id': APPID,
+                'X-Parse-Revocable-Session': '1',
+              },
+            }
+          );
+
+          // console.log("SignUp", SignUp);
+
+          if (SignUp.data) {
+            const sessiontoken = SignUp.data.sessionToken;
+            const payload = {
+              email: userEmail,
+              message: 'User Sign Up',
+              sessiontoken: sessiontoken,
+            };
+            return payload;
+          }
+        } catch (err) {
+          console.log('err in user sso sign up', err);
+          throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Internal server error.');
+        }
+      }
+    }
+  } catch (err) {
+    const errCode = err?.response?.status || err?.code || 400;
+    const message = err?.response?.data || err?.message || 'Internal server error.';
+    console.log('err in ssoSign', errCode, message);
+    throw new Parse.Error(errCode, message);
+  }
+}