shuttlepro-shared 1.1.97 → 1.1.99

package/config/bull.js

@@ -0,0 +1,78 @@
+const Queue = require("bull");
+const config = require("./config");
+
+/**
+ * Create a new queue.
+ * @param {string} queueName - The name of the queue.
+ * @param {Object} [redisConfig=config.redis] - Redis configuration.
+ * @returns {Object} - A collection of queue-related functions.
+ */
+const createQueue = (queueName, redisConfig = config.redis) => {
+  const queue = new Queue(queueName, { redis: redisConfig });
+
+  // Attach event listeners for logging
+  queue.on("completed", (job) => console.log(`Job ${job.id} completed.`));
+  queue.on("failed", (job, err) => console.error(`Job ${job.id} failed:`, err));
+
+  /**
+   * Add a job to the queue.
+   * @param {Object} data - Data to be processed by the job.
+   * @param {Object} [options] - Bull job options (e.g., delay, attempts).
+   * @returns {Promise<Job>} - The created job.
+   */
+  const addJob = async (
+    data,
+    options = {
+      attempts: 3,
+      removeOnComplete: true,
+    }
+  ) => {
+    return await queue.add(data, options);
+  };
+
+  /**
+   * Process jobs in the queue.
+   * @param {Function} processor - The function to process each job.
+   */
+  const processJobs = (processor) => {
+    queue.process(processor);
+  };
+
+  /**
+   * Close the queue connection.
+   * @returns {Promise<void>}
+   */
+  const closeConnection = async () => {
+    await queue.close();
+    console.log(`Queue "${queue.name}" connection closed.`);
+  };
+
+  /**
+   * Pause the queue.
+   * @returns {Promise<void>}
+   */
+  const pauseQueue = async () => {
+    await queue.pause();
+    console.log(`Queue "${queue.name}" paused.`);
+  };
+
+  /**
+   * Resume the queue.
+   * @returns {Promise<void>}
+   */
+  const resumeQueue = async () => {
+    await queue.resume();
+    console.log(`Queue "${queue.name}" resumed.`);
+  };
+
+  // Return the functional interface
+  return {
+    addJob,
+    processJobs,
+    closeConnection,
+    pauseQueue,
+    resumeQueue,
+  };
+};
+
+module.exports = { createQueue };

package/config/config.js

@@ -0,0 +1,14 @@
+const ALLOWED_URLS = process.env.ALLOWED_ORIGIN.split(",");
+const WEBHOOK_API_KEY = process.env.API_KEY || process.env.WEBHOOK_API_KEY;
+const mode = process.env.MODE || "production";
+
+const redis = {
+  url: process.env.REDIS_URI,
+};
+
+module.exports = {
+  WEBHOOK_API_KEY,
+  ALLOWED_URLS,
+  mode,
+  redis,
+};

package/config/database.js

@@ -0,0 +1,7 @@
+/* eslint-disable no-undef */
+module.exports = {
+  url:
+    process.env.NODE_ENV === "test"
+      ? process.env.TEST_DB_URL
+      : process.env.DB_URL,
+};

package/config/index.js

@@ -0,0 +1,13 @@
+const bullConfig = require("./bull");
+const redisConfig = require("./redis");
+const config = require("./config");
+const databaseConfig = require("./database");
+const socketConfig = require("./socket");
+
+module.exports = {
+  bullConfig,
+  redisConfig,
+  config,
+  databaseConfig,
+  socketConfig,
+};

package/config/redis.js

@@ -0,0 +1,189 @@
+const { createClient } = require("redis");
+require("dotenv").config();
+
+const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
+
+// ✅ Create main Redis client
+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();
+
+// ✅ 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 before performing operations
+const connectRedis = async () => {
+  if (!client.isOpen) {
+    try {
+      await client.connect();
+      await publisher.connect();
+      await subscriber.connect();
+    } catch (err) {
+      console.error("❌ Failed to connect to Redis:", err);
+    }
+  }
+  await client.configSet("notify-keyspace-events", "Ex");
+};
+
+/**
+ * ✅ 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));
+    console.log(`📢 Message published to channel: ${channel}`);
+  } catch (err) {
+    console.error("❌ Error publishing message:", err);
+  }
+};
+
+/**
+ * ✅ 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) => {
+  try {
+    await connectRedis();
+    await subscriber.subscribe(channel, (message) => {
+      console.log(`📥 Message received on channel: ${channel}`);
+      callback(JSON.parse(message));
+    });
+  } catch (err) {
+    console.error("❌ Error subscribing to channel:", err);
+  }
+};
+
+/**
+ * ✅ 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,
+  field = null,
+  expiryInSeconds = 3600
+) => {
+  try {
+    await connectRedis();
+    let result;
+    if (field) {
+      result = await client.hSet(key, field, JSON.stringify(value));
+    } else {
+      result = await client.set(key, JSON.stringify(value), {
+        EX: expiryInSeconds,
+      });
+    }
+    return result;
+  } catch (err) {
+    console.error("❌ Error setting Redis data:", err);
+    return null;
+  }
+};
+const addDataToRedisSet = async (key, value) => {
+  try {
+    await connectRedis();
+    await redisClient.sAdd(key, value);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+const removeDataFromRedisSet = async (key, value) => {
+  try {
+    await connectRedis();
+    await redisClient.sRem(key, value);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+const isMemberOfRedisSet = async (key, value) => {
+  try {
+    await connectRedis();
+    await redisClient.sIsMember(key, value);
+  } catch (err) {
+    return false;
+  }
+};
+/**
+ * ✅ Get Data from Redis (Supports String & Hash)
+ * @param {string} key - The Redis key
+ * @param {string|null} field - Optional field for Hash retrieval
+ */
+const getRedisData = async (key, field = null) => {
+  try {
+    await connectRedis();
+    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);
+    return null;
+  }
+};
+
+/**
+ * ✅ 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);
+    return null;
+  }
+};
+
+/**
+ * ✅ Graceful Shutdown Handling
+ */
+const closeClients = async () => {
+  if (client.isOpen) await client.quit();
+  if (publisher.isOpen) await publisher.quit();
+  if (subscriber.isOpen) await subscriber.quit();
+  console.log("❗ Redis Clients Disconnected Gracefully");
+};
+
+// ✅ Ensure Redis disconnects properly on process exit
+process.on("exit", closeClients);
+process.on("SIGINT", async () => {
+  await closeClients();
+  process.exit();
+});
+process.on("SIGTERM", async () => {
+  await closeClients();
+  process.exit();
+});
+
+// ✅ Export Functions
+module.exports = {
+  client,
+  publisher,
+  subscriber,
+  setRedisData,
+  getRedisData,
+  deleteRedisData,
+  publishToChannel,
+  subscribeToChannel,
+  connectRedis,
+  addDataToRedisSet,
+  removeDataFromRedisSet,
+  isMemberOfRedisSet,
+};

package/config/socket.js

@@ -0,0 +1,172 @@
+const { Server } = require("socket.io");
+const { publisher, subscriber, connectRedis } = require("./redis");
+require("dotenv").config();
+
+let io;
+const namespaceSockets = {}; // Store different namespace sockets
+
+/**
+ * Initialize Socket.IO server with namespaces
+ * @param {http.Server} server - HTTP server instance
+ * @param {string} namespaceParam - Socket namespace name (default: "conversation")
+ * @param {string} redisChannel - Redis channel for this namespace (default: "socket_events")
+ * @returns {SocketIO.Namespace} - The initialized namespace
+ */
+const initializeSocket = async (
+  server,
+  namespaceParam = "conversation",
+  redisChannel = "socket_events"
+) => {
+  // Initialize Socket.IO server if not already done
+  if (!io) {
+    io = new Server(server, {
+      cors: {
+        origin: "*",
+        methods: ["GET", "POST"],
+      },
+    });
+    console.log("✅ Socket.IO server initialized");
+  }
+
+  // Return existing namespace if already initialized
+  if (namespaceSockets[namespaceParam]) {
+    console.log(`📢 Using existing namespace: /${namespaceParam}`);
+    return namespaceSockets[namespaceParam];
+  }
+
+  // Create and store new namespace
+  const namespace = io.of(`/${namespaceParam}`);
+  namespaceSockets[namespaceParam] = namespace;
+  console.log(`🚀 Created new namespace: /${namespaceParam}`);
+
+  // Ensure Redis is connected
+  await connectRedis();
+
+  // Create a unique Redis channel for this namespace
+  const nsRedisChannel = `${redisChannel}_${namespaceParam}`;
+
+  // Subscribe to Redis events for this namespace
+  await subscriber.subscribe(nsRedisChannel, (messageStr) => {
+    try {
+      const message = JSON.parse(messageStr);
+      const { workspaceId, event, data } = message;
+
+      console.log(`📥 Redis message received on ${nsRedisChannel}:`, {
+        workspaceId,
+        event,
+      });
+
+      // Emit to specific workspace room in this namespace
+      if (workspaceId) {
+        namespace.to(workspaceId).emit(event, data);
+        console.log(
+          `📢 Event ${event} emitted to workspace ${workspaceId} in /${namespaceParam}`
+        );
+      } else {
+        // Broadcast to all clients in this namespace if no workspaceId specified
+        namespace.emit(event, data);
+        console.log(
+          `📢 Event ${event} broadcasted to all clients in /${namespaceParam}`
+        );
+      }
+    } catch (err) {
+      console.error(
+        `❌ Error handling Redis message on ${nsRedisChannel}:`,
+        err
+      );
+    }
+  });
+
+  // Handle new socket connections to this namespace
+  namespace.on("connection", (socket) => {
+    const { workspaceId } = socket.handshake.query;
+
+    if (!workspaceId) {
+      console.warn(`⚠️ Connection rejected: No workspaceId provided`);
+      socket.disconnect(true);
+      return;
+    }
+
+    console.log(
+      `✅ Client connected: ${socket.id} (Workspace: ${workspaceId}) in /${namespaceParam}`
+    );
+
+    // Join workspace room
+    socket.join(workspaceId);
+
+    // Send connection confirmation to client
+    socket.emit("connected", {
+      status: "connected",
+      socketId: socket.id,
+      namespace: namespaceParam,
+      workspaceId,
+    });
+
+    // Handle custom events from clients
+    socket.on("client_event", (data) => {
+      console.log(`📥 Client event from ${socket.id}:`, data);
+      // You can process client events here
+    });
+
+    // Handle disconnect
+    socket.on("disconnect", (reason) => {
+      console.log(
+        `❌ Client disconnected: ${socket.id} (Workspace: ${workspaceId}, Reason: ${reason})`
+      );
+      socket.leave(workspaceId);
+    });
+
+    // Handle errors
+    socket.on("error", (error) => {
+      console.error(`❌ Socket error for ${socket.id}:`, error);
+    });
+  });
+
+  console.log(
+    `✅ Namespace /${namespaceParam} initialized and listening on Redis channel: ${nsRedisChannel}`
+  );
+  return namespace;
+};
+
+/**
+ * Send event to clients via Redis pub/sub
+ * @param {object} params - Event parameters
+ * @param {string} params.workspaceId - Target workspace ID
+ * @param {string} params.event - Event name
+ * @param {any} params.data - Event data payload
+ * @param {string} [params.namespace="conversation"] - Target namespace
+ * @param {string} [params.redisChannel="socket_events"] - Base Redis channel
+ * @returns {Promise<void>}
+ */
+const sendEventToServer = async ({
+  workspaceId,
+  event,
+  data,
+  namespace = "conversation",
+  redisChannel = "socket_events",
+}) => {
+  try {
+    // Create namespace-specific Redis channel
+    const nsRedisChannel = `${redisChannel}_${namespace}`;
+
+    // Ensure Redis is connected
+    await connectRedis();
+
+    // Create message payload
+    const message = JSON.stringify({ workspaceId, event, data });
+
+    // Publish to Redis
+    await publisher.publish(nsRedisChannel, message);
+
+    console.log(
+      `📢 Event published to Redis channel ${nsRedisChannel}: ${event} (Workspace: ${workspaceId})`
+    );
+
+    return true;
+  } catch (err) {
+    console.error("❌ Error publishing to Redis:", err);
+    throw err;
+  }
+};
+
+module.exports = { initializeSocket, sendEventToServer };

package/constants/index.js

@@ -23,3 +23,18 @@ exports.GenericMessages = {
   URL_FETCH_SUCCESS: "Url Fetched successfully!",
   WORKSPACE_NOT_FOUND: "Workspace not found!",
 };
+
+exports.DYNAMIC_FIELD_TYPES = [
+  "text",
+  "autocomplete",
+  "radio",
+  "text area",
+  "number",
+  "date",
+  "time",
+  "email",
+  "range",
+  "url",
+  "colour",
+  "file",
+];

package/index.js

@@ -1,7 +1,15 @@
 const sharedModels = require("./models");
 const sharedFunctions = require("./functions");
+const logger = require("./utils/logger");
+const shuttlePro = require("./utils/decorator-factory");
+const configs = require("./config");
+const repositories = require("./common/repositories");
 
 module.exports = {
   sharedModels,
   sharedFunctions,
+  logger,
+  shuttlePro,
+  configs,
+  repositories,
 };

package/models/AgentActivity.js

@@ -0,0 +1,189 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const breakSchema = new mongoose.Schema({
+  refId: { type: String, required: true },
+  breakId: { type: String, required: false },
+  startTime: { type: Date, required: true },
+  endTime: { type: Date, required: false },
+});
+
+const responseSchema = new mongoose.Schema({
+  queryMessageId: { type: [String], default: [] },
+  responseMessageId: { type: [String], default: [] },
+  responseTime: { type: Number, required: false },
+  accuracy: { type: Number, required: false, default: 10 },
+});
+
+const activitySchema = new mongoose.Schema({
+  refId: { type: String, required: true },
+  type: {
+    type: String,
+    required: true,
+    default: "other",
+    enum: ["conversation", "ticket", "order", "other"],
+  },
+  platformName: { type: String, required: false },
+  platformType: { type: String, required: false },
+  customerName: { type: String, default: "", required: false },
+  conversationId: { type: String, default: "", required: false },
+  profileId: { type: String, required: false },
+  conversationType: {
+    type: String,
+    enum: ["email", "comment", "message", ""],
+    default: "",
+    required: false,
+  },
+  status: { type: String, required: false, default: "unassigned" },
+  labels: [{ type: Schema.Types.ObjectId, ref: "Label" }],
+  platformId: { type: String, required: false },
+  assignTime: { type: Date, required: false },
+  qaScore: { type: Number, required: false, default: 10 },
+  startTime: { type: String, required: false },
+  endTime: { type: String, required: false },
+  resolutionTime: { type: String, required: false },
+  responses: { type: [responseSchema], default: [] },
+  remarks: { type: String, required: false },
+  avgAccuracy: { type: Number, required: false, default: 10 },
+});
+
+const totalActivitySchema = new mongoose.Schema({
+  type: { type: String, required: true },
+  platformType: { type: String, required: false },
+  count: { type: Number, required: true },
+});
+
+const agentActivitySchema = new mongoose.Schema(
+  {
+    _id: {
+      type: mongoose.Schema.Types.ObjectId,
+      default: mongoose.Types.ObjectId,
+    },
+    agentId: { type: String, required: true },
+    agentRole: { type: String, default: "" },
+    agentName: { type: String, required: false },
+    agentShift: { type: Object, default: {}, required: false },
+    workspaceId: {
+      type: mongoose.Schema.Types.ObjectId,
+      required: true,
+      ref: "Workspace",
+    },
+    date: { type: String, required: true },
+    lateMinutes: {
+      type: Number,
+      default: 0,
+    },
+    earlyLeaveMinutes: {
+      type: Number,
+      default: 0,
+    },
+    shiftStartTime: { type: [Date], default: [] },
+    shiftEndTime: { type: [Date], default: [] },
+    shifts: [
+      {
+        shiftStartTime: { type: Date, required: true, default: null },
+        shiftEndTime: { type: Date, required: false, default: null },
+      },
+    ],
+    isLate: { type: Boolean, required: true, default: false },
+    isEarlyLeave: { type: Boolean, required: true, default: false },
+    breaks: { type: [breakSchema], default: [] },
+    activities: { type: [activitySchema], default: [] },
+    totalPsc: { type: Number, required: false, default: 0 },
+    totalQa: { type: Number, required: false, default: 0 },
+    weightedQa: { type: Number, required: false, default: 0 },
+    weightedPsc: { type: Number, required: false, default: 0 },
+    kpiScore: { type: Number, required: false, default: 0 },
+    totalActivities: { type: [totalActivitySchema], default: [] },
+    totalWorkTime: { type: Number, required: false, default: 0 },
+    totalBreakTime: { type: Number, required: false, default: 0 },
+    totalIdleTime: { type: Number, required: false, default: 0 },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+agentActivitySchema.index({ workspaceId: 1 });
+agentActivitySchema.index({ date: 1 });
+agentActivitySchema.index({ agentId: 1 });
+agentActivitySchema.index({ "activities.platformId": 1 });
+agentActivitySchema.index({ "activities.labels": 1 });
+agentActivitySchema.index({ workspaceId: 1, date: 1, agentId: 1 });
+agentActivitySchema.index({
+  workspaceId: 1,
+  date: 1,
+  agentId: 1,
+  "activities.platformId": 1,
+  "activities.labels": 1,
+});
+agentActivitySchema.index({
+  workspaceId: 1,
+  date: 1,
+  agentId: 1,
+  "activities.platformId": 1,
+});
+agentActivitySchema.index({
+  workspaceId: 1,
+  date: 1,
+  agentId: 1,
+  "activities.labels": 1,
+});
+agentActivitySchema.index(
+  { "activities.platformId": 1, "activities.labels": 1 },
+  {
+    partialFilterExpression: {
+      "activities.platformId": { $exists: true },
+      "activities.labels": { $exists: true },
+    },
+  }
+);
+const AgentActivity = mongoose.model("AgentActivity", agentActivitySchema);
+
+const findOneAndUpdateAgentActivity = async (
+  findQuery = {},
+  updateQuery = null
+) => {
+  try {
+    if (!findQuery || Object.values(findQuery).length === 0) {
+      console.log("Find Query is required.");
+      return null;
+    }
+
+    const agentActivityForActivitiesUpdated = await AgentActivity.findOne(
+      findQuery
+    ).sort({ createdAt: -1 });
+
+    if (!agentActivityForActivitiesUpdated) {
+      console.log("No matching record found.");
+      return null;
+    }
+
+    const bsonSize = require("bson").calculateObjectSize(
+      agentActivityForActivitiesUpdated
+    );
+
+    if (bsonSize <= 1000000) {
+      return await AgentActivity.findOneAndUpdate(findQuery, updateQuery);
+    } else {
+      const { breaks, activities, totalActivities, ...restData } =
+        agentActivityForActivitiesUpdated.toObject();
+
+      const newAgentActivity = await AgentActivity.create({
+        ...restData,
+      });
+
+      const agentActivityRecord = await AgentActivity.findOneAndUpdate(
+        { ...findQuery, _id: newAgentActivity._id },
+        updateQuery
+      );
+
+      return agentActivityRecord;
+    }
+  } catch (err) {
+    console.error("Error:", err);
+    return null;
+  }
+};
+module.exports = {
+  AgentActivity,
+  findOneAndUpdateAgentActivity,
+};