feat: add create document api with base64

apps/OpenSign/src/App.js

@@ -18,6 +18,7 @@ import LoadMf from "./routes/LoadMf";
 import GenerateToken from "./routes/GenerateToken";
 import ValidateRoute from "./primitives/ValidateRoute";
 import Webhook from "./routes/Webhook";
+import Validate from "./primitives/Validate";
 
 function App() {
   const [isloading, setIsLoading] = useState(true);
@@ -65,6 +66,9 @@ function App() {
               <Route exact path="/" element={<Login />} />
               <Route exact path="/signup" element={<Signup />} />
             </Route>
+            <Route element={<Validate />}>
+              <Route exact path="/load/:remoteApp/*" element={<LoadMf />} />
+            </Route>
             <Route exact path="/loadmf/:remoteApp/*" element={<LoadMf />} />
             <Route exact path="/forgetpassword" element={<ForgetPassword />} />
             {process.env.REACT_APP_ENABLE_SUBSCRIPTION && (

apps/OpenSign/src/primitives/Validate.js

@@ -0,0 +1,57 @@
+import React, { useState, useEffect } from "react";
+import Parse from "parse";
+import { Outlet, useNavigate, useLocation } from "react-router-dom";
+import ModalUi from "./ModalUi";
+const Validate = () => {
+  const navigate = useNavigate();
+  const location = useLocation();
+  const [isUserValid, setIsUserValid] = useState(true);
+  useEffect(() => {
+    (async () => {
+      try {
+        // Use the session token to validate the user
+        const userQuery = new Parse.Query(Parse.User);
+        const user = await userQuery.get(Parse.User.current().id, {
+          sessionToken: localStorage.getItem("accesstoken")
+        });
+        if (user) {
+          setIsUserValid(true);
+        } else {
+          setIsUserValid(false);
+        }
+      } catch (error) {
+        // Session token is invalid or there was an error
+        setIsUserValid(false);
+      }
+    })();
+  }, []);
+  const handleLoginBtn = () => {
+    try {
+      Parse.User.logOut();
+    } catch (err) {
+      console.log("err ", err);
+    } finally {
+      localStorage.removeItem("accesstoken");
+      navigate("/", { replace: true, state: { from: location } });
+    }
+  };
+  return isUserValid ? (
+    <div>
+      <Outlet />
+    </div>
+  ) : (
+    <ModalUi title={"Session Expired"} isOpen={true} showClose={false}>
+      <div className="flex flex-col justify-center items-center py-4 md:py-5 gap-5">
+        <p className="text-xl font-normal">Your session has expired.</p>
+        <button
+          onClick={handleLoginBtn}
+          className="text-base px-3 py-1.5 rounded shadow-md text-white bg-[#1ab6ce]"
+        >
+          Login
+        </button>
+      </div>
+    </ModalUi>
+  );
+};
+
+export default Validate;

apps/OpenSignServer/cloud/customRoute/v1/apiV1.js

@@ -49,7 +49,10 @@ app.delete('/contact/:contact_id', deleteContact);
 app.get('/contactlist', getContactList);
 
 // create Document
-app.post('/createdocument', upload.array('file', 1), createDocument);
+app.post('/createdocumentwithbinary', upload.array('file', 1), createDocument);
+
+// create Document with base64
+app.post('/createdocument', createDocument);
 
 // create Document with templateId
 app.post('/createdocument/:template_id', createDocumentWithTemplate);

apps/OpenSignServer/cloud/customRoute/v1/routes/createDocument.js

@@ -1,13 +1,16 @@
-const randomId = () => Math.floor(1000 + Math.random() * 9000);
+// import batchQuery from './batchquery.js';
+
+// const randomId = () => Math.floor(1000 + Math.random() * 9000);
 export default async function createDocument(request, response) {
   const name = request.body.Title;
   const note = request.body.Note;
   const description = request.body.Description;
   const signers = request.body.Signers;
   const folderId = request.body.FolderId;
-  // const file = request.body.file;
-  const url = process.env.SERVER_URL;
-  const fileData = request.files[0] ? request.files[0].buffer : null;
+  const base64File = request.body.file;
+  const url = request?.get('host');
+  const fileData = request.files?.[0] ? request.files[0].buffer : null;
+  console.log('fileData ', fileData);
   try {
     const reqToken = request.headers['x-api-token'];
     if (!reqToken) {
@@ -18,55 +21,116 @@ export default async function createDocument(request, response) {
     const token = await tokenQuery.first({ useMasterKey: true });
     if (token !== undefined) {
       // Valid Token then proceed request
-      const userPtr = token.get('userId');
-
-      const file = new Parse.File(request.files?.[0]?.originalname, {
-        base64: fileData.toString('base64'),
-      });
-      await file.save({ useMasterKey: true });
-      const fileUrl = file.url();
-      const contractsUser = new Parse.Query('contracts_Users');
-      contractsUser.equalTo('UserId', userPtr);
-      const extUser = await contractsUser.first({ useMasterKey: true });
-      const extUserPtr = { __type: 'Pointer', className: 'contracts_Users', objectId: extUser.id };
-
-      const folderPtr = { __type: 'Pointer', className: 'contracts_Document', objectId: folderId };
-
-      const object = new Parse.Object('contracts_Document');
-      object.set('Name', name);
-      if (note) {
-        object.set('Note', note);
-      }
-      if (description) {
-        object.set('Description', description);
-      }
-      object.set('URL', fileUrl);
-      object.set('CreatedBy', userPtr);
-      object.set('ExtUserPtr', extUserPtr);
       if (signers) {
-        const parseSigners = JSON.parse(signers);
-        const placeholders = parseSigners.map(x => ({
-          email: x,
-          Id: randomId(),
-          Role: '',
-          blockColor: '',
-          signerObjId: '',
-          signerPtr: {},
-          placeHolder: [],
-        }));
-        object.set('Placeholders', placeholders);
+        const userPtr = token.get('userId');
+        let fileUrl;
+        if (request.files?.[0]) {
+          const file = new Parse.File(request.files?.[0]?.originalname, {
+            base64: fileData?.toString('base64'),
+          });
+          await file.save({ useMasterKey: true });
+          fileUrl = file.url();
+        } else {
+          const file = new Parse.File(`${name}.pdf`, {
+            base64: base64File,
+          });
+          await file.save({ useMasterKey: true });
+          fileUrl = file.url();
+        }
+        const contractsUser = new Parse.Query('contracts_Users');
+        contractsUser.equalTo('UserId', userPtr);
+        const extUser = await contractsUser.first({ useMasterKey: true });
+        const extUserPtr = {
+          __type: 'Pointer',
+          className: 'contracts_Users',
+          objectId: extUser.id,
+        };
+
+        const folderPtr = {
+          __type: 'Pointer',
+          className: 'contracts_Document',
+          objectId: folderId,
+        };
+
+        const object = new Parse.Object('contracts_Document');
+        object.set('Name', name);
+        if (note) {
+          object.set('Note', note);
+        }
+        if (description) {
+          object.set('Description', description);
+        }
+        object.set('URL', fileUrl);
+        object.set('CreatedBy', userPtr);
+        object.set('ExtUserPtr', extUserPtr);
+        if (signers) {
+          let parseSigners;
+          if (base64File) {
+            parseSigners = signers;
+          } else {
+            parseSigners = JSON.parse(signers);
+          }
+
+          const contactbook = new Parse.Query('contracts_Contactbook');
+          contactbook.equalTo('UserId', userPtr);
+          contactbook.notEqualTo('IsDeleted', true);
+          contactbook.containedIn('Email', parseSigners);
+          const contactbookRes = await contactbook.find({ useMasterKey: true });
+          console.log('contactbookRes ', contactbookRes);
+          const parseContactbookRes = JSON.parse(JSON.stringify(contactbookRes));
+          // console.log('userPtr ', userPtr);
+          // const newContacts = parseSigners
+          //   .filter(x => !parseContactbookRes.some(y => y.Email === x))
+          //   .map(email => ({
+          //     method: 'POST',
+          //     path: '/app/classes/contracts_Contactbook',
+          //     body: {
+          //       Email: email,
+          //       CreatedBy: { __type: 'Pointer', className: '_User', objectId: userPtr.id },
+          //       UserId: { __type: 'Pointer', className: '_User', objectId: userPtr.id },
+          //       Role: 'contracts_Guest',
+          //       IsDeleted: false,
+          //       ACL: {
+          //         [userPtr.id]: { read: true, write: true },
+          //       },
+          //     },
+          //   }));
+          // console.log('newContacts', newContacts);
+          let contactSigners = parseContactbookRes?.map(x => ({
+            __type: 'Pointer',
+            className: 'contracts_Contactbook',
+            objectId: x.objectId,
+          }));
+          // if (newContacts.length > 0) {
+          //   const batchRes = await batchQuery(newContacts);
+          //   const contacts = batchRes?.map(x => ({
+          //     __type: 'Pointer',
+          //     className: 'contracts_Contactbook',
+          //     objectId: x.success.objectId,
+          //   }));
+          //   contactSigners = [...contactSigners, ...contacts];
+          // }
+          // console.log('contactsigners', contactSigners);
+
+          object.set('Signers', contactSigners);
+        }
+        if (folderId) {
+          object.set('Folder', folderPtr);
+        }
+        const newACL = new Parse.ACL();
+        newACL.setPublicReadAccess(false);
+        newACL.setPublicWriteAccess(false);
+        newACL.setReadAccess(userPtr.id, true);
+        newACL.setWriteAccess(userPtr.id, true);
+        object.setACL(newACL);
+        const res = await object.save(null, { useMasterKey: true });
+        return response.json({
+          objectId: res.id,
+          url: 'https://' + url + '/load/signmicroapp/placeholdersign/' + res.id,
+        });
+      } else {
+        return response.status(400).json({ error: 'Please provide signers!' });
       }
-      if (folderId) {
-        object.set('Folder', folderPtr);
-      }
-      const newACL = new Parse.ACL();
-      newACL.setPublicReadAccess(false);
-      newACL.setPublicWriteAccess(false);
-      newACL.setReadAccess(userPtr.id, true);
-      newACL.setWriteAccess(userPtr.id, true);
-      object.setACL(newACL);
-      const res = await object.save(null, { useMasterKey: true });
-      return response.json({ objectId: res.id, url: url });
     } else {
       return response.status(405).json({ error: 'Invalid API Token!' });
     }