Merge pull request #630 from OpenSignLabs/gmail_provider

feat: add google mail provider

Author: nxglabs

apps/OpenSignServer/cloud/customRoute/customApp.js

@@ -6,6 +6,7 @@ import uploadFile from './uploadFile.js';
 import saveSubscription from './saveSubscription.js';
 import saveInvoice from './saveInvoice.js';
 import savePayments from './savePayments.js';
+import gooogleauth from './googleauth.js';
 export const app = express();
 
 dotenv.config();
@@ -18,5 +19,7 @@ app.post('/file_upload', uploadFile);
 app.post('/savesubscription', saveSubscription)
 app.post('/saveinvoice', saveInvoice)
 app.post('/savepayment', savePayments)
+app.post('/googleauth', gooogleauth)
+
 
 

apps/OpenSignServer/cloud/customRoute/googleauth.js

@@ -0,0 +1,53 @@
+import axios from 'axios';
+const appId = process.env.APP_ID;
+const serverUrl = process.env.SERVER_URL;
+export default async function gooogleauth(request, response) {
+  const code = request.body.code;
+  const baseUrl = new URL(process.env.SERVER_URL);
+  //   const sessiontoken = request.headers;
+  //   console.log('sessiontoken', sessiontoken);
+  //   console.log('google code', code);
+  try {
+    const userRes = await axios.get(serverUrl + '/users/me', {
+      headers: {
+        'X-Parse-Application-Id': appId,
+        'X-Parse-Session-Token': request.headers['sessiontoken'],
+      },
+    });
+    const userId = userRes.data && userRes.data.objectId;
+    if (userId) {
+      const clientId = process.env.GOOGLE_CLIENT_ID; // '918704711393-thhv3re2pfqvve76tgb86ulu1tlpssrk.apps.googleusercontent.com';
+      const clientSecret = process.env.GOOGLE_CLIENT_SECRET; //'3NqyXVNm4jUhwNE4D8eVosII';
+      const redirectUri = baseUrl.origin || 'http://localhost:3000'; // Should match the redirect URI used in the authorization request
+      const tokenEndpoint = 'https://oauth2.googleapis.com/token';
+
+      const params = new URLSearchParams();
+      params.append('code', code);
+      params.append('client_id', clientId);
+      params.append('client_secret', clientSecret);
+      params.append('redirect_uri', redirectUri);
+      params.append('grant_type', 'authorization_code');
+
+      const res = await axios.post(tokenEndpoint, params);
+      //   console.log('oauthres ', res.data);
+      const refresh_token = res.data.refresh_token;
+      const extUserCls = new Parse.Query('contracts_Users');
+      extUserCls.equalTo('UserId', { __type: 'Pointer', className: '_User', objectId: userId });
+      const extUser = await extUserCls.first({ useMasterKey: true });
+
+      if (extUser) {
+        const extUserCls = new Parse.Object('contracts_Users');
+        extUserCls.id = extUser.id;
+        extUserCls.set('google_refresh_token', refresh_token);
+        const updateExtUser = await extUserCls.save(null, { useMasterKey: true });
+        // console.log('updateExtUser ', updateExtUser);
+      }
+      return response.status(200).json({ status: 'success!' });
+    } else {
+      return response.status(404).json({ message: 'user not found!' });
+    }
+  } catch (err) {
+    console.log('err in google auth', err.message);
+    return response.status(404).json({ message: err.message });
+  }
+}

apps/OpenSignServer/cloud/parsefunction/getUserDetails.js

@@ -5,6 +5,7 @@ async function getUserDetails(request) {
     userQuery.equalTo('Email', request.params.email);
     userQuery.include('TenantId');
     userQuery.include('UserId');
+    userQuery.exclude('google_refresh_token')
     if (userId) {
       userQuery.equalTo('CreatedBy', { __type: 'Pointer', className: '_User', objectId: userId });
     }

apps/OpenSignServer/cloud/parsefunction/pdf/PDF.min.js

@@ -94,16 +94,17 @@ async function sendCompletedMail(e) {
     } catch (e) {
       console.log('error in fetch tenant in signpdf', e.message);
     }
-  e = {
+  g = {
     extUserId: s.objectId,
     url: a,
     from: 'OpenSign™',
     recipient: i,
     subject: o,
     pdfName: r,
     html: n,
+    mailProvider: e.mailProvider,
   };
-  await axios.post(serverUrl + '/functions/sendmailv3', e, {
+  await axios.post(serverUrl + '/functions/sendmailv3', g, {
     headers: {
       'Content-Type': 'application/json',
       'X-Parse-Application-Id': APPID,
@@ -173,8 +174,9 @@ async function PDF(o) {
   try {
     var n = o.params.docId,
       e = o.params.userId,
-      l = o.params.isCustomCompletionMail,
-      d = await axios.get(
+      l = o.params.isCustomCompletionMail || !1,
+      d = o.params.mailProvider || '',
+      c = await axios.get(
         serverUrl + '/classes/contracts_Document/' + n + '?include=ExtUserPtr,Signers',
         {
           headers: {
@@ -184,33 +186,33 @@ async function PDF(o) {
           },
         }
       ),
-      c = await axios.get(serverUrl + '/users/me', {
+      p = await axios.get(serverUrl + '/users/me', {
         headers: {
           'X-Parse-Application-Id': APPID,
           'X-Parse-Session-Token': o.headers.sessiontoken,
         },
       });
-    if (!c.data || !c.data.objectId) return { status: 'error', message: 'This user not allowed!' };
+    if (!p.data || !p.data.objectId) return { status: 'error', message: 'This user not allowed!' };
     {
       var a,
         t,
         s,
-        p = JSON.stringify({ objectId: e });
+        m = JSON.stringify({ objectId: e });
       let r, i;
       i = e
-        ? (a = await axios.get(serverUrl + '/classes/contracts_Contactbook?where=' + p, {
+        ? (a = await axios.get(serverUrl + '/classes/contracts_Contactbook?where=' + m, {
             headers: {
               'X-Parse-Application-Id': APPID,
               'X-Parse-Session-Token': o.headers.sessiontoken,
             },
           })).data && 0 < a.data.results.length
           ? ((r = a), 'contracts_Contactbook')
-          : ((r = await axios.get(serverUrl + '/classes/contracts_Users?where=' + p, {
+          : ((r = await axios.get(serverUrl + '/classes/contracts_Users?where=' + m, {
               headers: { 'X-Parse-Application-Id': APPID, 'X-Parse-Master-Key': masterKEY },
             })),
             'contracts_Users')
         : ((t = JSON.stringify({
-            UserId: { __type: 'Pointer', className: '_User', objectId: c.data.objectId },
+            UserId: { __type: 'Pointer', className: '_User', objectId: p.data.objectId },
           })),
           (s = await axios.get(serverUrl + '/classes/contracts_Users?where=' + t, {
             headers: { 'X-Parse-Application-Id': APPID, 'X-Parse-Master-Key': masterKEY },
@@ -223,125 +225,130 @@ async function PDF(o) {
                 },
               })),
               'contracts_Contactbook'));
-      var m = r.data.results[0].Name,
-        g = r.data.results[0].Email;
+      var g = r.data.results[0].Name,
+        u = r.data.results[0].Email;
       if (!o.params.pdfFile) return { status: 'error', message: 'Pdf file not present!' };
       {
         let e = Buffer.from(o.params.pdfFile, 'base64');
-        var u = process.env.PFX_BASE64,
-          h = Buffer.from(u, 'base64'),
-          f = {
+        var h = process.env.PFX_BASE64,
+          f = Buffer.from(h, 'base64'),
+          P = {
             UserPtr: { __type: 'Pointer', className: i, objectId: r.data.results[0].objectId },
             SignedUrl: '',
             Activity: 'Signed',
             ipAddress: o.headers['x-real-ip'],
           };
         let a;
-        var P = (a =
-          d.data.AuditTrail && 0 < d.data.AuditTrail.length
-            ? [...d.data.AuditTrail, f]
-            : [f]).filter(e => 'Signed' === e.Activity);
+        var y = (a =
+          c.data.AuditTrail && 0 < c.data.AuditTrail.length
+            ? [...c.data.AuditTrail, P]
+            : [P]).filter(e => 'Signed' === e.Activity);
         let t = !1;
         !(
-          (d.data.Signers && 0 < d.data.Signers.length && P.length !== d.data.Signers.length) ||
+          (c.data.Signers && 0 < c.data.Signers.length && y.length !== c.data.Signers.length) ||
           !(t = !0)
         );
-        var y,
+        var v,
           b,
-          v,
           U,
           I,
           w,
-          D = `exported_file_${Math.floor(5e3 * Math.random())}.pdf`,
-          S = './exports/' + D;
+          D,
+          S = `exported_file_${Math.floor(5e3 * Math.random())}.pdf`,
+          _ = './exports/' + S;
         let s = e.length;
         s = (
           t
-            ? ((y = d.data.Signers?.map(e => e.Name + ' <' + e.Email + '>')),
+            ? ((v = c.data.Signers?.map(e => e.Name + ' <' + e.Email + '>')),
               (e =
-                y && 0 < y.length
+                v && 0 < v.length
                   ? ((b = await PDFDocument.load(e)),
                     pdflibAddPlaceholder({
                       pdfDoc: b,
-                      reason: 'Digitally signed by OpenSign for ' + y?.join(', '),
+                      reason: 'Digitally signed by OpenSign for ' + v?.join(', '),
                       location: 'n/a',
                       signatureLength: 15e3,
                     }),
-                    (v = await b.save()),
-                    Buffer.from(v))
-                  : ((U = await PDFDocument.load(e)),
+                    (U = await b.save()),
+                    Buffer.from(U))
+                  : ((I = await PDFDocument.load(e)),
                     pdflibAddPlaceholder({
-                      pdfDoc: U,
-                      reason: 'Digitally signed by OpenSign for ' + m + ' <' + g + '>',
+                      pdfDoc: I,
+                      reason: 'Digitally signed by OpenSign for ' + g + ' <' + u + '>',
                       location: 'n/a',
                       signatureLength: 15e3,
                     }),
-                    (I = await U.save()),
-                    Buffer.from(I))),
-              (w = await new SignPDF(e, h).signPDF()),
-              fs.writeFileSync(S, w),
-              w)
-            : (fs.writeFileSync(S, e), e)
+                    (w = await I.save()),
+                    Buffer.from(w))),
+              (D = await new SignPDF(e, f).signPDF()),
+              fs.writeFileSync(_, D),
+              D)
+            : (fs.writeFileSync(_, e), e)
         ).length;
-        var _,
-          A,
+        var A,
           x,
           E,
           j,
           k,
           F,
           C,
           T,
-          N = await uploadFile(D, S);
-        if (N && N.imageUrl)
+          N,
+          M = await uploadFile(S, _);
+        if (M && M.imageUrl)
           return (
-            (_ = await updateDoc(
+            (A = await updateDoc(
               o.params.docId,
-              N.imageUrl,
+              M.imageUrl,
               r.data.results[0].objectId,
               o.headers['x-real-ip'],
-              d.data,
+              c.data,
               i
             )),
-            sendDoctoWebhook(d, N.imageUrl, 'signed', r?.data.results?.[0]),
-            saveFileUsage(s, N.imageUrl, c.data.objectId),
-            _ &&
-              _.isCompleted &&
-              ((A = { ...d.data, AuditTrail: _.AuditTrail }),
-              (x = await GenerateCertificate(A)),
-              (E = await PDFDocument.load(x)),
+            sendDoctoWebhook(c, M.imageUrl, 'signed', r?.data.results?.[0]),
+            saveFileUsage(s, M.imageUrl, p.data.objectId),
+            A &&
+              A.isCompleted &&
+              ((x = { ...c.data, AuditTrail: A.AuditTrail }),
+              (E = await GenerateCertificate(x)),
+              (j = await PDFDocument.load(E)),
               pdflibAddPlaceholder({
-                pdfDoc: E,
+                pdfDoc: j,
                 reason: 'Digitally signed by OpenSign.',
                 location: 'n/a',
                 signatureLength: 15e3,
               }),
-              (j = await E.save()),
-              (k = Buffer.from(j)),
-              (F = await new SignPDF(k, h).signPDF()),
-              fs.writeFileSync('./exports/certificate.pdf', F),
-              (T = {
-                CertificateUrl: (C = await uploadFile(
+              (k = await j.save()),
+              (F = Buffer.from(k)),
+              (C = await new SignPDF(F, f).signPDF()),
+              fs.writeFileSync('./exports/certificate.pdf', C),
+              (N = {
+                CertificateUrl: (T = await uploadFile(
                   'certificate.pdf',
                   './exports/certificate.pdf'
                 )).imageUrl,
               }),
-              await axios.put(serverUrl + '/classes/contracts_Document/' + n, T, {
+              await axios.put(serverUrl + '/classes/contracts_Document/' + n, N, {
                 headers: {
                   'Content-Type': 'application/json',
                   'X-Parse-Application-Id': APPID,
                   'X-Parse-Master-Key': masterKEY,
                 },
               }),
-              d.data.IsSendMail && !1 === d.data.IsSendMail
+              c.data.IsSendMail && !1 === c.data.IsSendMail
                 ? console.log("don't send mail")
-                : sendCompletedMail({ url: N.imageUrl, isCustomMail: l, doc: d.data }),
-              saveFileUsage(k.length, C.imageUrl, c.data.objectId),
-              sendDoctoWebhook(d, N.imageUrl, 'completed')),
-            fs.unlinkSync(S),
-            console.log('New Signed PDF created called: ' + S),
-            'success' === _.message
-              ? { status: 'success', data: N.imageUrl }
+                : sendCompletedMail({
+                    url: M.imageUrl,
+                    isCustomMail: l,
+                    doc: c.data,
+                    mailProvider: d,
+                  }),
+              saveFileUsage(F.length, T.imageUrl, p.data.objectId),
+              sendDoctoWebhook(c, M.imageUrl, 'completed')),
+            fs.unlinkSync(_),
+            console.log('New Signed PDF created called: ' + _),
+            'success' === A.message
+              ? { status: 'success', data: M.imageUrl }
               : { status: 'error', message: 'Please provide required parameters!' }
           );
       }