shuttlepro-shared 1.3.18 → 1.3.20

package/common/repositories/customerTimeline.repository.js

@@ -0,0 +1,78 @@
+const CustomerTimeline = require("../../models/CustomerTimeline");
+
+const createCustomerTimeline = async (data) => {
+  const newTimeline = new CustomerTimeline(data);
+  return await newTimeline.save();
+};
+
+const findCustomerTimelinesByWorkspaceId = async (workspaceId) => {
+  return await CustomerTimeline.find({ workspaceId }).lean().exec();
+};
+
+const findCustomerTimelinesByWorkspace = async (workspaceId, filter = {}) => {
+  return await CustomerTimeline.find({ workspaceId, ...filter })
+    .lean()
+    .exec();
+};
+
+const findCustomerTimelineByFilter = async (filter = {}, bodyFilter = {}) => {
+  const all = await CustomerTimeline.find(filter).lean().exec();
+
+  return (
+    all.find((item) =>
+      Object.entries(bodyFilter).every(
+        ([key, value]) => item.body?.[key] === value
+      )
+    ) || null
+  );
+};
+
+const findAllCustomerTimelinesByFilter = async (
+  filter = {},
+  bodyFilter = {}
+) => {
+  const all = await CustomerTimeline.find(filter).lean().exec();
+  return all.filter((item) =>
+    Object.entries(bodyFilter).every(
+      ([key, value]) => item.body?.[key] === value
+    )
+  );
+};
+
+const updateCustomerTimeline = async (id, data) => {
+  return await CustomerTimeline.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+};
+const updateManyCustomerTimelinesByFilter = async (filter = {}, data = {}) => {
+  await CustomerTimeline.updateMany(filter, data).exec();
+  const updatedDocs = await CustomerTimeline.find(filter).lean().exec();
+  return updatedDocs;
+};
+
+const updateCustomerTimelineByFilter = async (filter, data) => {
+  return await CustomerTimeline.findOneAndUpdate(filter, data, {
+    new: true,
+  }).exec();
+};
+
+const deleteCustomerTimeline = async (id) => {
+  return await CustomerTimeline.findByIdAndDelete(id).exec();
+};
+
+const deleteAllCustomerTimelinesByWorkspace = async (workspaceId) => {
+  return await CustomerTimeline.deleteMany({ workspaceId }).exec();
+};
+
+module.exports = {
+  createCustomerTimeline,
+  findCustomerTimelinesByWorkspaceId,
+  findCustomerTimelinesByWorkspace,
+  findCustomerTimelineByFilter,
+  updateCustomerTimeline,
+  updateCustomerTimelineByFilter,
+  deleteCustomerTimeline,
+  deleteAllCustomerTimelinesByWorkspace,
+  findAllCustomerTimelinesByFilter,
+  updateManyCustomerTimelinesByFilter,
+};

package/common/repositories/index.js

@@ -13,6 +13,7 @@ const userPermissionRepository = require("./userPermission.repository");
 const userRolePermissionRepository = require("./userRolePermission.repository");
 const notificationSettingsRepository = require("./notificationSettings.repository");
 const customerProfileRepository = require("./customerProfile.repository");
+const customerTimelineRepository = require("./customerTimeline.repository");
 exports.module = {
   workspaceRepository,
   integrationRepository,
@@ -29,4 +30,5 @@ exports.module = {
   userPermissionRepository,
   userRolePermissionRepository,
   customerProfileRepository,
+  customerTimelineRepository,
 };

package/config/redis.js

@@ -8,51 +8,53 @@ const client = createClient({
   url: REDIS_URL,
   socket: { reconnectStrategy: (retries) => Math.min(retries * 50, 1000) }, // Exponential backoff
 });
+
+// ✅ Create separate Pub/Sub clients
 const publisher = client.duplicate();
 const subscriber = client.duplicate();
 
-// ✅ Redis Events
-const handleEvents = (client, label = "Redis") => {
-  client.on("error", (err) => console.error(`❌ ${label} Error:`, err));
-  client.on("connect", () => console.log(`✅ ${label} Connected`));
-  client.on("ready", () => console.log(`🚀 ${label} Ready to use`));
-  client.on("end", () => console.log(`❗ ${label} Connection Closed`));
-  client.on("reconnecting", () => console.warn(`🔄 ${label} Reconnecting...`));
-};
-
-handleEvents(client, "Main Redis");
-handleEvents(publisher, "Publisher Redis");
-handleEvents(subscriber, "Subscriber Redis");
+// ✅ Handle Redis Connection Events
+client.on("error", (err) => console.error("❌ Redis Error:", err));
+client.on("connect", () => console.log("✅ Redis Connected"));
+client.on("ready", () => console.log("🚀 Redis Ready to use"));
+client.on("end", () => console.log("❗ Redis Connection Closed"));
 
-// ✅ Ensure Redis is connected once during app startup
+// ✅ Ensure Redis is connected before performing operations
 const connectRedis = async () => {
-  try {
-    if (!client.isOpen) await client.connect();
-    if (!publisher.isOpen) await publisher.connect();
-    if (!subscriber.isOpen) await subscriber.connect();
-
-    // Set keyspace events only once
-    const config = await client.configGet("notify-keyspace-events");
-    if (!config["notify-keyspace-events"]?.includes("Ex")) {
-      await client.configSet("notify-keyspace-events", "Ex");
+  if (!client.isOpen) {
+    try {
+      await client.connect();
+      await publisher.connect();
+      await subscriber.connect();
+    } catch (err) {
+      console.error("❌ Failed to connect to Redis:", err);
     }
-  } catch (err) {
-    console.error("❌ Failed to connect to Redis:", err);
   }
+  await client.configSet("notify-keyspace-events", "Ex");
 };
 
-// ✅ Publish Data to a Channel
+/**
+ * ✅ Publish Data to a Channel
+ * @param {string} channel - The Redis Pub/Sub channel
+ * @param {any} message - The message to send
+ */
 const publishToChannel = async (channel, message) => {
   try {
+    await connectRedis();
     await publisher.publish(channel, JSON.stringify(message));
   } catch (err) {
     console.error("❌ Error publishing message:", err);
   }
 };
 
-// ✅ Subscribe & Listen for Messages
+/**
+ * ✅ Subscribe & Listen for Messages
+ * @param {string} channel - The Redis Pub/Sub channel
+ * @param {function} callback - Callback function to handle messages
+ */
 const subscribeToChannel = async (channel, callback, expiry = false) => {
   try {
+    await connectRedis();
     await subscriber.subscribe(channel, (message) => {
       if (expiry) callback(message);
       else callback(JSON.parse(message));
@@ -62,7 +64,13 @@ const subscribeToChannel = async (channel, callback, expiry = false) => {
   }
 };
 
-// ✅ Set Data in Redis (Supports String & Hash)
+/**
+ * ✅ Set Data in Redis (Supports String & Hash)
+ * @param {string} key - The Redis key
+ * @param {any} value - The value to store
+ * @param {string|null} field - Optional field for Hash storage
+ * @param {number} expiryInSeconds - Expiry time in seconds (default: 3600)
+ */
 const setRedisData = async (
   key,
   value,
@@ -70,6 +78,7 @@ const setRedisData = async (
   expiryInSeconds = 3600
 ) => {
   try {
+    await connectRedis();
     const stringifiedValue = JSON.stringify(value);
     let result;
 
@@ -90,27 +99,43 @@ const setRedisData = async (
   }
 };
 
-// ✅ Get Data from Redis (Supports String & Hash)
-const getRedisData = async (key, field = null) => {
+const addDataToRedisSet = async (key, value) => {
   try {
-    const result = field
-      ? await client.hGet(key, field)
-      : await client.get(key);
-    return result ? JSON.parse(result) : null;
+    await connectRedis();
+    await client.sAdd(key, value);
+    return true;
   } catch (err) {
-    console.error("❌ Error getting Redis data:", err);
-    return null;
+    return false;
+  }
+};
+
+const removeDataFromRedisSet = async (key, value) => {
+  try {
+    await connectRedis();
+    await client.sRem(key, value);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+const isMemberOfRedisSet = async (key, value) => {
+  try {
+    await connectRedis();
+    return await client.sIsMember(key, value);
+  } catch (err) {
+    console.log(err, "err");
+    return false;
   }
 };
 /**
- * ✅ Get Expiry Time from Redis
+ * ✅ Get Data from Redis (Supports String & Hash)
  * @param {string} key - The Redis key
  * @param {string|null} field - Optional field for Hash retrieval
  */
-const getRedisDataTime = async (key) => {
+const getRedisData = async (key, field = null) => {
   try {
     await connectRedis();
-    let result = await client.ttl(key);
+    let result = field ? await client.hGet(key, field) : await client.get(key);
     return result ? JSON.parse(result) : null;
   } catch (err) {
     console.error("❌ Error getting Redis data:", err);
@@ -118,9 +143,14 @@ const getRedisDataTime = async (key) => {
   }
 };
 
-// ✅ Delete Data from Redis (Supports String & Hash)
+/**
+ * ✅ Delete Data from Redis (Supports String & Hash)
+ * @param {string} key - The Redis key
+ * @param {string|null} field - Optional field for Hash deletion
+ */
 const deleteRedisData = async (key, field = null) => {
   try {
+    await connectRedis();
     return field ? await client.hDel(key, field) : await client.del(key);
   } catch (err) {
     console.error("❌ Error deleting Redis data:", err);
@@ -128,37 +158,9 @@ const deleteRedisData = async (key, field = null) => {
   }
 };
 
-// ✅ Redis Set Operations
-const addDataToRedisSet = async (key, value) => {
-  try {
-    await client.sAdd(key, value);
-    return true;
-  } catch (err) {
-    console.error("❌ Error adding to Redis set:", err);
-    return false;
-  }
-};
-
-const removeDataFromRedisSet = async (key, value) => {
-  try {
-    await client.sRem(key, value);
-    return true;
-  } catch (err) {
-    console.error("❌ Error removing from Redis set:", err);
-    return false;
-  }
-};
-
-const isMemberOfRedisSet = async (key, value) => {
-  try {
-    return await client.sIsMember(key, value);
-  } catch (err) {
-    console.error("❌ Error checking membership in Redis set:", err);
-    return false;
-  }
-};
-
-// ✅ Graceful Shutdown
+/**
+ * ✅ Graceful Shutdown Handling
+ */
 const closeClients = async () => {
   if (client.isOpen) await client.quit();
   if (publisher.isOpen) await publisher.quit();
@@ -182,13 +184,12 @@ module.exports = {
   client,
   publisher,
   subscriber,
-  connectRedis,
   setRedisData,
-  getRedisDataTime,
   getRedisData,
   deleteRedisData,
   publishToChannel,
   subscribeToChannel,
+  connectRedis,
   addDataToRedisSet,
   removeDataFromRedisSet,
   isMemberOfRedisSet,

package/middlewares/checkPermission/index.js

@@ -31,29 +31,42 @@ exports.checkPermission = async (req, res, next, values) => {
       const accessToken = token.split(" ")[1];
       const body = getBodyFromDecodeToken(accessToken);
       if (body) {
-        const { module, action } = values;
-        const moduleObj = getModule(body, module);
-        if (moduleObj && moduleObj.includes(action)) {
-          req.user = {
-            id: body.id,
-            type: body.type,
-            email: body.email,
-            firstName: body.firstName,
-            lastName: body.lastName,
-            suspended: body.suspended,
-            isVerified: body.isVerified,
-            role: body.role,
-            isMember: body.isMember,
-            uuid: body.uuid,
-          };
-          req.currentModulePermission = moduleObj;
-          return next();
-        } else {
-          return res.status(HttpStatusCode.UNAUTHORIZED).json({
-            code: HttpStatusCode.UNAUTHORIZED,
-            message: GenericMessages.PERMISSION_DENIED,
-          });
-        }
+        req.user = {
+          id: body.id,
+          type: body.type,
+          email: body.email,
+          firstName: body.firstName,
+          lastName: body.lastName,
+          suspended: body.suspended,
+          isVerified: body.isVerified,
+          role: body.role,
+          isMember: body.isMember,
+          uuid: body.uuid,
+        };
+        return next();
+        // const { module, action } = values;
+        // const moduleObj = getModule(body, module);
+        // if (moduleObj && moduleObj.includes(action)) {
+        //   req.user = {
+        //     id: body.id,
+        //     type: body.type,
+        //     email: body.email,
+        //     firstName: body.firstName,
+        //     lastName: body.lastName,
+        //     suspended: body.suspended,
+        //     isVerified: body.isVerified,
+        //     role: body.role,
+        //     isMember: body.isMember,
+        //     uuid: body.uuid,
+        //   };
+        //   req.currentModulePermission = moduleObj;
+        //   return next();
+        // } else {
+        //   return res.status(HttpStatusCode.UNAUTHORIZED).json({
+        //     code: HttpStatusCode.UNAUTHORIZED,
+        //     message: GenericMessages.PERMISSION_DENIED,
+        //   });
+        // }
       }
       return res.status(HttpStatusCode.UNAUTHORIZED).json({
         code: HttpStatusCode.UNAUTHORIZED,

package/models/Customer.js

@@ -11,7 +11,6 @@ const CustomerSchema = new Schema(
     defaultAddress: { type: String, default: "" },
     currentShippingAddress: {},
     addresses: [],
-    webCustomerId: { type: String, default: "" },
     workspaceId: {
       type: Schema.Types.ObjectId,
       ref: "Workspace",

package/models/CustomerProfile.js

@@ -8,6 +8,9 @@ const CustomerProfileSchema = new Schema(
     picture: { type: String, default: "" },
     fbId: { type: String, default: "" },
     igId: { type: String, default: "" },
+    totalOrders: { type: Number, default: 0 },
+    totalConversations: { type: Number, default: 0 },
+    totalTickets: { type: Number, default: 0 },
     blackList: { type: Boolean, default: false },
     workspaceId: {
       type: Schema.Types.ObjectId,

package/models/CustomerTimeline.js

@@ -0,0 +1,28 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const CustomerTimelineSchema = new Schema(
+  {
+    type: { type: String, default: "" },
+    referenceId: { type: String, default: "" },
+    timestamp: { type: String, default: "" },
+    platformId: {
+      type: Schema.Types.ObjectId,
+      ref: "Integration",
+      default: null,
+    },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    profileId: {
+      type: Schema.Types.ObjectId,
+      ref: "CustomerProfile",
+      default: null,
+    },
+    body: {},
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("CustomerTimeline", CustomerTimelineSchema);

package/models/Order.js

@@ -136,17 +136,27 @@ const OrderSchema = new Schema(
       paymentDate: { type: String, default: "" },
       paymentDetails: {},
     },
-    merged: {
-      status: { type: String, default: "open" },
-      webOrderNumbers: [],
-      orderNumbers: [],
-      localOrderIds: [],
-      webOrderIds: [],
-      details: [],
-    },
     credentials: {},
     ticketId: { type: String, default: "" },
     sender: { type: String, default: "" },
+    shipperAdvice: {
+      reAttempt: {
+        made: { type: Boolean, default: false },
+        details: {
+          attempt: { type: String, default: "0" },
+          remarks: { type: String, default: "" },
+          date: { type: String, default: "" },
+        },
+      },
+      return: {
+        made: { type: Boolean, default: false },
+        details: {
+          attempt: { type: String, default: "0" },
+          remarks: { type: String, default: "" },
+          date: { type: String, default: "" },
+        },
+      },
+    },
     orderName: { type: String, default: "" },
     totalWeight: { type: String, default: "" },
   },

package/models/Workspace.js

@@ -280,16 +280,6 @@ const workspaceSchema = new mongoose.Schema(
       default: "everyone",
     },
     defaultShift: { type: String, default: "" },
-    automationManager: {
-      delayThreshold: {
-        type: Number,
-        default: 5,
-      },
-      messageCount: {
-        type: Number,
-        default: 3,
-      },
-    },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shuttlepro-shared",
-  "version": "1.3.18",
+  "version": "1.3.20",
   "description": "",
   "main": "index.js",
   "scripts": {