zet-lib 1.4.11 → 1.4.13

package/lib/zAppRouter.js

@@ -1,3 +1,4 @@
+require("dotenv").config();
 const express = require("express");
 const router = express.Router();
 const csrf = require("csurf");
@@ -23,7 +24,8 @@ const qs = require("qs");
 const zip = require("express-zip");
 const sharp = require("sharp");
 const path = require("path");
-
+const { Dropbox } = require("dropbox");
+const fetch = require("isomorphic-fetch");
 /*
  ajax Post
  */
@@ -403,8 +405,8 @@ router.post("/signup-custom", async (req, res) => {
       },
     });
     /* await zRoute.loginAjax(dataUser.username, body.password, req, res);
-         //refresh cache
-         await zCache.renew();*/
+             //refresh cache
+             await zCache.renew();*/
 
     res.json(Util.jsonSuccess("Successfuly"));
   } catch (e) {
@@ -708,15 +710,15 @@ router.post("/zzapproval", async (req, res) => {
     if (data.status == 2) {
       //send activity
       /* await zRoute.insertSQL(req, res, "zactivity", {
-                 user_id: res.locals.userId,
-                 table: MYMODEL.table,
-                 id_data: data.id,
-                 status: data.status,
-                 status_label: MYMODEL.widgets.status.fields[data.status],
-                 title: MYMODEL.widgets.status.fields[data.status],
-                 description: users[res.locals.userId].fname + " " +users[res.locals.userId].lname ,
-                 data: JSON.stringify(data)
-             });*/
+                       user_id: res.locals.userId,
+                       table: MYMODEL.table,
+                       id_data: data.id,
+                       status: data.status,
+                       status_label: MYMODEL.widgets.status.fields[data.status],
+                       title: MYMODEL.widgets.status.fields[data.status],
+                       description: users[res.locals.userId].fname + " " +users[res.locals.userId].lname ,
+                       data: JSON.stringify(data)
+                   });*/
       //if serial
       if (data.type == 2) {
         approvers = [approvers[0]];
@@ -786,38 +788,38 @@ router.post("/zzapproval", async (req, res) => {
           textWa += `Please click the link above to view the document.\r\n${link}`;
 
           /* await whatsapp({
-                         to: phone,
-                         text: textWa,
-                         sections: JSON.stringify(sections),
-                         buttonText: "Click me for details"
-                     });*/
+                                   to: phone,
+                                   text: textWa,
+                                   sections: JSON.stringify(sections),
+                                   buttonText: "Click me for details"
+                               });*/
         }
 
         //send notification
         /* await zRoute.insertSQL(req, res, "znotification", {
-                     user_id: item,
-                     table: MYMODEL.table,
-                     id_data: data.id,
-                     status: 1,
-                     link: "/za/" + post.token,
-                     status_label: MYMODEL.widgets.status.fields[1],
-                     title: `Need Approve`,
-                     description: data.title,
-                     token: post.token
-                 });*/
+                             user_id: item,
+                             table: MYMODEL.table,
+                             id_data: data.id,
+                             status: 1,
+                             link: "/za/" + post.token,
+                             status_label: MYMODEL.widgets.status.fields[1],
+                             title: `Need Approve`,
+                             description: data.title,
+                             token: post.token
+                         });*/
 
         //send todolist
         /* await zRoute.insertSQL(req, res, "ztodolist", {
-                     user_id: item,
-                     table: MYMODEL.table,
-                     id_data: data.id,
-                     status: 1,
-                     link: "/za/" + post.token,
-                     status_label: MYMODEL.widgets.status.fields[1],
-                     title: `Need Approve`,
-                     description: data.title,
-                     users: JSON.stringify(allUsers)
-                 });*/
+                             user_id: item,
+                             table: MYMODEL.table,
+                             id_data: data.id,
+                             status: 1,
+                             link: "/za/" + post.token,
+                             status_label: MYMODEL.widgets.status.fields[1],
+                             title: `Need Approve`,
+                             description: data.title,
+                             users: JSON.stringify(allUsers)
+                         });*/
 
         //send toastr using socket.io
         io.to(users[item].token).emit("message", "Need Approve " + data.title);
@@ -863,50 +865,50 @@ router.post("/zzapproval", async (req, res) => {
           textWa += "We have some document for you.\r\n";
           textWa += `Please click the link above to view the document.\r\n${link}`;
           /*  await whatsapp({
-                          to: phone,
-                          text: textWa,
-                          sections: JSON.stringify(sections),
-                          buttonText: "Click me for details"
-                      });*/
+                                    to: phone,
+                                    text: textWa,
+                                    sections: JSON.stringify(sections),
+                                    buttonText: "Click me for details"
+                                });*/
         }
 
         //send activity
         /*                await cRoute.insertSQL(req, res, "zactivity",{
-                 user_id:item,
-                 table:MYMODEL.table,
-                 id_data:data.id,
-                 status:7,
-                 status_label: MYMODEL.widgets.status.fields[7],
-                 title : MYMODEL.widgets.status.fields[7],
-                 description: data.title,
-                 data:JSON.stringify(data)
-                 });*/
+                         user_id:item,
+                         table:MYMODEL.table,
+                         id_data:data.id,
+                         status:7,
+                         status_label: MYMODEL.widgets.status.fields[7],
+                         title : MYMODEL.widgets.status.fields[7],
+                         description: data.title,
+                         data:JSON.stringify(data)
+                         });*/
 
         //send notification
         /*   await zRoute.insertSQL(req, res, "znotification", {
-                       user_id: item,
-                       table: MYMODEL.table,
-                       id_data: data.id,
-                       status: 1,
-                       link: "/za/" + post.token,
-                       status_label: MYMODEL.widgets.status.fields[1],
-                       title: `Need Acknowledge`,
-                       description: data.title,
-                       token: post.token
-                   });
-
-                   //send todolist
-                   await zRoute.insertSQL(req, res, "ztodolist", {
-                       user_id: item,
-                       table: MYMODEL.table,
-                       id_data: data.id,
-                       status: 1,
-                       link: "/za/" + post.token,
-                       status_label: MYMODEL.widgets.status.fields[1],
-                       title: `Need Acknowledge`,
-                       description: data.title,
-                       users: JSON.stringify(allUsers)
-                   });*/
+                               user_id: item,
+                               table: MYMODEL.table,
+                               id_data: data.id,
+                               status: 1,
+                               link: "/za/" + post.token,
+                               status_label: MYMODEL.widgets.status.fields[1],
+                               title: `Need Acknowledge`,
+                               description: data.title,
+                               token: post.token
+                           });
+
+                           //send todolist
+                           await zRoute.insertSQL(req, res, "ztodolist", {
+                               user_id: item,
+                               table: MYMODEL.table,
+                               id_data: data.id,
+                               status: 1,
+                               link: "/za/" + post.token,
+                               status_label: MYMODEL.widgets.status.fields[1],
+                               title: `Need Acknowledge`,
+                               description: data.title,
+                               users: JSON.stringify(allUsers)
+                           });*/
         io.to(users[item].token).emit(
           "message",
           "Need Acknowledge " + data.title
@@ -1042,23 +1044,23 @@ router.get("/za/:token", csrfProtection, async (req, res) => {
     if (result.mystatus == 7) {
       MYMODEL = MYMODELS["zapprovals"];
       /* await connection.insert({
-                 table: "zactivity",
-                 data: {
-                     company_id: result.company_id,
-                     created_at: Util.now(),
-                     created_by: result.user_id,
-                     updated_by: result.user_id,
-                     user_id: result.user_id,
-                     table: MYMODEL.table,
-                     id_data: result.ide,
-                     status: 6,
-                     status_label: MYMODEL.widgets.status.fields[6],
-                     title: `${MYMODEL.widgets.status.fields[6]}`,
-                     description: `Ok `,
-                     data: JSON.stringify(data)
-                 }
-             });
- */
+                       table: "zactivity",
+                       data: {
+                           company_id: result.company_id,
+                           created_at: Util.now(),
+                           created_by: result.user_id,
+                           updated_by: result.user_id,
+                           user_id: result.user_id,
+                           table: MYMODEL.table,
+                           id_data: result.ide,
+                           status: 6,
+                           status_label: MYMODEL.widgets.status.fields[6],
+                           title: `${MYMODEL.widgets.status.fields[6]}`,
+                           description: `Ok `,
+                           data: JSON.stringify(data)
+                       }
+                   });
+       */
 
       await connection.update({
         table: "zapprovals_details",
@@ -1636,6 +1638,7 @@ router.post("/zdropzone-remove", async (req, res) => {
     res.status(500).send(e + "");
   }
 });
+
 router.post("/zdropzone-attributes", async (req, res) => {
   try {
     let userId = res.locals.userId;
@@ -1859,4 +1862,288 @@ router.post("/zcompress-dropzone", async (req, res) => {
   }
 });
 
+//for dropbox
+// Initialize Dropbox client
+let dbx = new Dropbox({
+  accessToken: process.env.DROPBOX_ACCESS_TOKEN,
+  refreshToken: process.env.DROPBOX_REFRESH_TOKEN,
+  clientId: process.env.DROPBOX_CLIENT_ID,
+  clientSecret: process.env.DROPBOX_CLIENT_SECRET,
+  fetch: fetch,
+});
+
+// Function to refresh access token
+async function refreshAccessToken() {
+  try {
+    const response = await fetch("https://api.dropbox.com/oauth2/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: process.env.DROPBOX_REFRESH_TOKEN,
+        client_id: process.env.DROPBOX_CLIENT_ID,
+        client_secret: process.env.DROPBOX_CLIENT_SECRET,
+      }),
+    });
+
+    const data = await response.json();
+
+    if (data.access_token) {
+      // Update the access token in the Dropbox client
+      dbx = new Dropbox({
+        accessToken: data.access_token,
+        refreshToken: process.env.DROPBOX_REFRESH_TOKEN,
+        clientId: process.env.DROPBOX_CLIENT_ID,
+        clientSecret: process.env.DROPBOX_CLIENT_SECRET,
+        fetch: fetch,
+      });
+
+      // Update the .env file with the new access token
+      const envContent = fs.readFileSync(`${dirRoot}/.env`, "utf8");
+      const updatedEnv = envContent.replace(
+        /DROPBOX_ACCESS_TOKEN=.*/,
+        `DROPBOX_ACCESS_TOKEN=${data.access_token}`
+      );
+      fs.writeFileSync(`${dirRoot}/.env`, updatedEnv);
+
+      return data.access_token;
+    } else {
+      throw new Error("Failed to refresh access token");
+    }
+  } catch (error) {
+    console.error("Error refreshing access token:", error);
+    throw error;
+  }
+}
+
+// Middleware to handle token refresh
+async function handleTokenRefresh(req, res, next) {
+  try {
+    // Try to make a test API call
+    await dbx.usersGetCurrentAccount();
+    next();
+  } catch (error) {
+    if (error.status === 401) {
+      try {
+        // Token expired, try to refresh it
+        await refreshAccessToken();
+        next();
+      } catch (refreshError) {
+        res
+          .status(401)
+          .json({ error: "Authentication failed. Please re-authenticate." });
+      }
+    } else {
+      next(error);
+    }
+  }
+}
+
+// Serve static files
+//app.use(express.static('public'));
+// Create test folder if it doesn't exist
+//dir = '/test'
+async function ensureFolder(dir) {
+  try {
+    await dbx.filesCreateFolderV2({
+      path: dir,
+      autorename: false,
+    });
+  } catch (error) {
+    if (error.status !== 409) {
+      // 409 means folder already exists
+      throw error;
+    }
+  }
+}
+
+// Function to delay execution
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// Upload endpoint
+router.post("/zdropbox/:table/:field", handleTokenRefresh, async (req, res) => {
+  try {
+    if (!req.files || !req.files.file) {
+      return res.status(400).json({ error: "No file uploaded" });
+    }
+
+    const userId = res.locals.userId;
+    const table = req.params.table;
+    const field = req.params.field;
+    const file = req.files.file;
+    const fileName = file.name;
+    //ensure folder
+    const dir = `/temps/${table}/${field}/${userId}`;
+    await ensureFolder(dir);
+    const filePath = `${dir}/${fileName}`;
+
+    console.log("Uploading file to path:", filePath);
+    console.log("File size:", file.size);
+    console.log("File name:", fileName);
+
+    const response = await dbx.filesUpload({
+      path: filePath,
+      contents: file.data,
+      mode: { ".tag": "add" },
+      autorename: true,
+    });
+    res.json("ok");
+  } catch (error) {
+    console.error("Upload error:", error);
+    console.error("Error details:", {
+      message: error.message,
+      stack: error.stack,
+      response: error.response,
+    });
+    res.status(500).json({
+      error: "Failed to upload file",
+      details: error.message,
+    });
+  }
+});
+
+router.post("/zdropbox-attributes", handleTokenRefresh, async (req, res) => {
+  try {
+    let userId = res.locals.userId;
+    let dir = `${dirRoot}/public/zdropzone/${userId}`;
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    let body = req.body;
+    let category = body.category;
+    let name = `dropbox__${userId}__${body.table}__${body.field}__${body.type}`;
+    //dropzone__${res.locals.userId}__${table}__${key}__create
+    let arr = myCache.has(name) ? myCache.get(name) : [];
+    if (category === "add") {
+      arr.push(body.file);
+    } else {
+      name = `dropzone__${userId}__${body.table}__${body.field}__${body.type}`;
+      if (myCache.has(name)) {
+        arr = myCache.get(name);
+      }
+      arr = Util.arrayDelete(arr, body.file);
+    }
+    myCache.set(name, arr);
+    res.json("ok");
+  } catch (e) {
+    console.log(e);
+    res.status(500).send(e + "");
+  }
+});
+
+//get all files and meta in dropbox
+router.post("/zdropbox-files", handleTokenRefresh, async (req, res) => {
+  let datas = [];
+  const room = res.locals.token;
+  try {
+    const { files, table, field } = req.body;
+    let dir = `/${table}/${field}`;
+    for (file of files) {
+      let pathFile = `${dir}/${file.fileName}`;
+      //console.log(pathFile)
+      try {
+        const metadata = await dbx.filesGetMetadata({
+          path: pathFile,
+        });
+        let link = ``;
+        try {
+          const response = await dbx.filesGetTemporaryLink({
+            path: pathFile,
+          });
+          link = response.result.link;
+        } catch (error) {
+          console.error("Error getting temporary link:", error);
+          io.to(room).emit(
+            "errormessage",
+            `Error getting temporary link:  ${error.message}`
+          );
+        }
+
+        const mockFile = {
+          name: metadata.result.name,
+          id: metadata.result,
+          path: metadata.result.path_display,
+          link: link,
+          isImage: metadata.result.name.match(/\.(jpg|jpeg|png|gif)$/i),
+          size: metadata.result.size,
+          modified: metadata.result.server_modified,
+          accepted: true,
+        };
+        //console.log(mockFile)
+        datas.push(mockFile);
+      } catch (e) {
+        console.log(e);
+        io.to(room).emit(
+          "errormessage",
+          `${e.message} Error ${pathFile} not exist in dropbox`
+        );
+      }
+    }
+  } catch (e) {
+    console.log(e);
+    res.status(500).send(e + "");
+  }
+  res.json(datas);
+});
+
+// Delete file
+router.post("/zdropbox-delete/", handleTokenRefresh, async (req, res) => {
+  try {
+    let body = req.body;
+    let path = body.path;
+    const filePath = decodeURIComponent(req.params.path);
+    await dbx.filesDeleteV2({
+      path: filePath,
+    });
+    res.json({ success: true });
+  } catch (error) {
+    console.error("Error deleting file:", error);
+    res.status(500).json({ error: "Error deleting file" });
+  }
+});
+
+// Endpoint to check token status
+router.get("/zdropbox-check-token", handleTokenRefresh, async (req, res) => {
+  try {
+    await dbx.usersGetCurrentAccount();
+    res.json({ status: "valid" });
+  } catch (error) {
+    res.status(401).json({ status: "invalid" });
+  }
+});
+
+// Get temporary link for a file
+router.post("/zdropbox-get-temp-link", handleTokenRefresh, async (req, res) => {
+  try {
+    const response = await dbx.filesGetTemporaryLink({
+      path: req.body.path,
+    });
+    res.json({ link: response.result.link });
+  } catch (error) {
+    console.error("Error getting temporary link:", error);
+    res.status(500).json({ error: "Error getting temporary link" });
+  }
+});
+
+router.get(
+  "/zdropbox-view/:table/:field/:item",
+  handleTokenRefresh,
+  async (req, res) => {
+    try {
+      let item = req.params.item;
+      item = item.substring(13);
+      let filePath = `/${req.params.table}/${req.params.field}/${req.params.item}`;
+      const response = await dbx.filesGetTemporaryLink({
+        path: filePath,
+      });
+      res.send(`<img src="${response.result.link}">`);
+    } catch (e) {
+      console.log(e);
+      res.send(e);
+    }
+  }
+);
+
 module.exports = router;