shuttlepro-shared 1.3.38 → 1.3.40

package/common/repositories/customerProfile.repository.js

@@ -1,103 +1,42 @@
-const { getRedisData, setRedisData } = require("../../config/redis");
 const CustomerProfile = require("../../models/CustomerProfile");
 
-const CACHE_KEY_ALL = "customer_profiles_all";
-
-const getCachedAllCustomerProfiles = async () => {
-  let profiles = await getRedisData(CACHE_KEY_ALL);
-  if (!profiles) {
-    profiles = await CustomerProfile.find({}).lean().exec();
-    await setRedisData(CACHE_KEY_ALL, profiles);
-  }
-  return profiles;
-};
-
-const updateCachedAllCustomerProfiles = async () => {
-  const profiles = await CustomerProfile.find({}).lean().exec();
-  await setRedisData(CACHE_KEY_ALL, profiles);
-};
-
-const getCachedCustomerProfiles = async (workspaceId) => {
-  const allProfiles = await getCachedAllCustomerProfiles();
-  return allProfiles.filter((profile) => profile.workspaceId === workspaceId);
-};
-
 const createCustomerProfile = async (data) => {
   const newProfile = new CustomerProfile(data);
   const savedProfile = await newProfile.save();
-
-  updateCachedAllCustomerProfiles();
   return savedProfile;
 };
 
 const findCustomerProfilesByWorkspaceId = async (workspaceId) => {
-  return await getCachedCustomerProfiles(workspaceId);
+  return await CustomerProfile.find({ workspaceId }).lean().exec();
 };
 
 const findCustomerProfilesByWorkspace = async (workspaceId, filter = {}) => {
-  const profiles = await getCachedCustomerProfiles(workspaceId);
-  return profiles.filter((profile) =>
-    Object.entries(filter).every(([key, value]) => profile[key] === value)
-  );
+  return await CustomerProfile.find({ workspaceId, ...filter })
+    .lean()
+    .exec();
 };
 
 const findCustomerProfileByFilter = async (
   filter = {},
-  bodyFilter = {},
+
   workspaceId = null
 ) => {
-  const allProfiles = await getCachedAllCustomerProfiles();
-
-  const filtered = workspaceId
-    ? allProfiles.filter((p) => p.workspaceId === workspaceId)
-    : allProfiles;
-
-  return (
-    filtered.find(
-      (profile) =>
-        Object.entries(filter).every(
-          ([key, value]) => profile[key] === value
-        ) &&
-        Object.entries(bodyFilter).every(
-          ([key, value]) => profile.body?.[key] === value
-        )
-    ) || null
-  );
+  const query = workspaceId ? { ...filter, workspaceId } : filter;
+  return await CustomerProfile.findOne(query).lean().exec();
 };
 
 const findAllCustomerProfilesByFilter = async (
   filter = {},
-  bodyFilter = {},
   workspaceId = null
 ) => {
-  const allProfiles = await getCachedAllCustomerProfiles();
-
-  const filtered = workspaceId
-    ? allProfiles.filter((p) => p.workspaceId === workspaceId)
-    : allProfiles;
-
-  return (
-    filtered.filter(
-      (profile) =>
-        Object.entries(filter).every(
-          ([key, value]) => profile[key] === value
-        ) &&
-        Object.entries(bodyFilter).every(
-          ([key, value]) => profile.body?.[key] === value
-        )
-    ) || []
-  );
+  const query = workspaceId ? { ...filter, workspaceId } : filter;
+  return await CustomerProfile.find(query).lean().exec();
 };
 
 const updateCustomerProfile = async (id, data) => {
   const updated = await CustomerProfile.findByIdAndUpdate(id, data, {
     new: true,
   }).exec();
-
-  if (updated) {
-    updateCachedAllCustomerProfiles();
-  }
-
   return updated;
 };
 
@@ -107,33 +46,24 @@ const updateCustomerProfileByFilter = async (
   workspaceId = null
 ) => {
   const query = workspaceId ? { ...filter, workspaceId } : filter;
-
   const updated = await CustomerProfile.findOneAndUpdate(query, data, {
     new: true,
   }).exec();
-
-  if (updated) {
-    updateCachedAllCustomerProfiles();
-  }
-
   return updated;
 };
 
 const deleteCustomerProfile = async (id) => {
   const deleted = await CustomerProfile.findByIdAndDelete(id).exec();
-
-  if (deleted) {
-    updateCachedAllCustomerProfiles();
-  }
-
   return deleted;
 };
 
 const deleteAllCustomerProfilesByWorkspace = async (workspaceId) => {
   await CustomerProfile.deleteMany({ workspaceId }).exec();
-  await updateCachedAllCustomerProfiles();
 };
-
+const findAllCustomerProfilesByFilterFromDb = async (filter = {}) => {
+  const profiles = await CustomerProfile.find(filter).lean().exec();
+  return profiles ?? [];
+};
 module.exports = {
   createCustomerProfile,
   findCustomerProfilesByWorkspaceId,
@@ -144,4 +74,5 @@ module.exports = {
   deleteCustomerProfile,
   deleteAllCustomerProfilesByWorkspace,
   findAllCustomerProfilesByFilter,
+  findAllCustomerProfilesByFilterFromDb,
 };

package/common/repositories/userRole.repository.js

@@ -2,7 +2,7 @@ const { UserRole } = require("../../models/UserRole");
 const { getRedisData, setRedisData } = require("../../config/redis");
 
 const defaultSelect =
-  "iconUrl thumbUrl name productsCount ordersCount contact email address websiteUrl facebookUrl twitterUrl instagramUrl members defaultModule allowedModules";
+  "iconUrl thumbUrl name productsCount ordersCount contact email address websiteUrl facebookUrl twitterUrl instagramUrl members defaultModule";
 
 // Cache keys
 const MEMBERS = "members";
@@ -35,7 +35,6 @@ const updateCachedMembers = async (workspaceId) => {
 
 const getMembers = async (workspaceId) => {
   let members = await getRedisData(workspaceId, MEMBERS);
-  
   if (!members || members?.length === 0) {
     members = await UserRole.find({ workspaceId })
       .select("userId role userShift roleId isOwner workspaceId")
@@ -54,7 +53,6 @@ const getMembers = async (workspaceId) => {
       .exec();
     await setRedisData(workspaceId, members, MEMBERS, 3600);
   }
-
   return members;
 };
 
@@ -63,8 +61,7 @@ const getMemberByWorkspaceIdAndUserId = async (workspaceId, userId) => {
   return (
     members?.find(
       (member) =>
-        member?.workspaceId?.toString() === workspaceId?.toString() &&
-        member?.userId?._id?.toString() === userId?.toString()
+        member?.workspaceId === workspaceId && member?.userId?._id === userId
     ) || null
   );
 };

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,42 +31,29 @@ exports.checkPermission = async (req, res, next, values) => {
       const accessToken = token.split(" ")[1];
       const body = getBodyFromDecodeToken(accessToken);
       if (body) {
-        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,
-        //   });
-        // }
+        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/ActivityLogs.js

@@ -28,7 +28,6 @@ const ActivityLogsSchema = new Schema(
       type: String,
       default: "",
     },
-    body: {},
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/models/AgentActivity.js

@@ -47,6 +47,8 @@ const activitySchema = new mongoose.Schema({
   remarks: { type: String, required: false },
   avgAccuracy: { type: Number, required: false, default: 10 },
   sender: { type: String, required: "" },
+  members: [],
+  closedBy: {},
 });
 
 const totalActivitySchema = new mongoose.Schema({
@@ -164,9 +166,7 @@ const findOneAndUpdateAgentActivity = async (
     );
 
     if (bsonSize <= 1000000) {
-      return await AgentActivity.findOneAndUpdate(findQuery, updateQuery, {
-        new: true,
-      });
+      return await AgentActivity.findOneAndUpdate(findQuery, updateQuery);
     } else {
       const { breaks, activities, totalActivities, ...restData } =
         agentActivityForActivitiesUpdated.toObject();
@@ -177,8 +177,7 @@ const findOneAndUpdateAgentActivity = async (
 
       const agentActivityRecord = await AgentActivity.findOneAndUpdate(
         { ...findQuery, _id: newAgentActivity._id },
-        updateQuery,
-        { new: true }
+        updateQuery
       );
 
       return agentActivityRecord;

package/models/Card.js

@@ -91,20 +91,7 @@ const cardSchema = new mongoose.Schema(
         },
         fieldType: {
           type: String,
-          enum: [
-            "text",
-            "autocomplete",
-            "radio",
-            "text area",
-            "number",
-            "date",
-            "time",
-            "email",
-            "range",
-            "url",
-            "colour",
-            "file",
-          ],
+          enum: DYNAMIC_FIELD_TYPES,
         },
         fieldValueId: {
           type: mongoose.Schema.Types.Mixed,
@@ -120,42 +107,6 @@ const cardSchema = new mongoose.Schema(
         },
       },
     ],
-    assignId: {
-      type: mongoose.Schema.Types.Mixed,
-      default: null,
-    },
-    mergedTickets: {
-      type: [
-        {
-          id: { type: String, required: false },
-          ticketId: { type: String, required: false },
-        },
-      ],
-      default: [],
-    },
-    mergedInto: {
-      type: {
-        id: { type: String, required: false, default: "" },
-        ticketId: { type: String, required: false, default: "" },
-      },
-      default: null,
-    },
-    customerName: {
-      type: String,
-      default: "",
-    },
-    customerEmail: {
-      type: String,
-      default: "",
-    },
-    phoneNo: {
-      type: String,
-      default: "",
-    },
-    body: {
-      type: mongoose.Schema.Types.Mixed,
-      default: {},
-    },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/models/Chatbot.js

@@ -17,4 +17,4 @@ const ChatbotSchema = new Schema(
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );
-module.exports = ChatbotSchema;
+module.exports = model("Chatbot", ChatbotSchema);

package/models/Column.js

@@ -14,12 +14,6 @@ const columnSchema = new mongoose.Schema(
       type: Boolean,
       default: false,
     },
-    type: {
-      type: String,
-      enum: ["open", "processing", "hold", "closed"],
-      required: true,
-      default: "open",
-    },
     workspaceId: { type: String, default: "" },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }

package/models/Conversation.js

@@ -10,14 +10,6 @@ const draftSchema = new mongoose.Schema({
   createdBy: { type: Schema.Types.ObjectId, ref: "User" },
 });
 
-const activitySchema = new mongoose.Schema({
-  action: { type: String, default: null },
-  previousAssignee: { type: Schema.Types.ObjectId, ref: "User", default: null },
-  newAssignee: { type: Schema.Types.ObjectId, ref: "User", default: null },
-  timestamp: { type: Date, default: Date.now },
-  performedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-});
-
 const conversationSchema = new mongoose.Schema(
   {
     platformType: {
@@ -84,44 +76,12 @@ const conversationSchema = new mongoose.Schema(
     draft: [draftSchema],
     isWebchatTicket: { type: Boolean, default: false },
     webchatComplaintType: { type: String, default: null },
-    isWebchatAutoReply: { type: Boolean, default: false },
-
     isComposed: { type: Boolean, default: false },
-    userMessageTime: { type: String, default: "" },
     utilityMessage: [],
     orderId: [],
     isFetch: { type: Boolean, default: true },
-    isAwaitingFeedback: { type: Boolean, default: true },
-    activities: [activitySchema],
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );
 
-conversationSchema.index({ workspaceId: 1, isSpam: 1 });
-conversationSchema.index({ workspaceId: 1, isSpam: 1, conversationStatus: 1 });
-conversationSchema.index({
-  workspaceId: 1,
-  isSpam: 1,
-  platformId: 1,
-});
-conversationSchema.index({
-  workspaceId: 1,
-  isSpam: 1,
-  platformId: 1,
-  conversationStatus: 1,
-});
-conversationSchema.index({
-  workspaceId: 1,
-  isSpam: 1,
-  platformId: 1,
-  conversationType: 1,
-});
-conversationSchema.index({
-  workspaceId: 1,
-  isSpam: 1,
-  platformId: 1,
-  conversationType: 1,
-  conversationStatus: 1,
-});
-
 module.exports = mongoose.model("Conversation", conversationSchema);