shuttlepro-shared 1.3.13 → 1.3.14

package/config/bull.js

@@ -1,78 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,4 +0,0 @@
-/* eslint-disable no-undef */
-module.exports = {
-  url: process.env.DB_URL,
-};

package/config/index.js

@@ -1,13 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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));
-  } 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, expiry = false) => {
-  try {
-    await connectRedis();
-    await subscriber.subscribe(channel, (message) => {
-      if (expiry) callback(message);
-      else 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();
-    const stringifiedValue = JSON.stringify(value);
-    let result;
-
-    if (field) {
-      result = await client.hSet(key, field, stringifiedValue);
-      if (expiryInSeconds) {
-        await client.expire(key, expiryInSeconds);
-      }
-    } else {
-      result = expiryInSeconds
-        ? await client.set(key, stringifiedValue, { EX: expiryInSeconds })
-        : await client.set(key, stringifiedValue);
-    }
-    return result;
-  } catch (err) {
-    console.error("❌ Error setting Redis data:", err);
-    return null;
-  }
-};
-
-const addDataToRedisSet = async (key, value) => {
-  try {
-    await connectRedis();
-    await client.sAdd(key, value);
-    return true;
-  } catch (err) {
-    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 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

@@ -1,172 +0,0 @@
-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/models/AgentActivity.js

@@ -1,192 +0,0 @@
-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" },
-  sourceType: { type: String, required: false, default: "normal" },
-  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 },
-  sender: { type: String, required: "" },
-});
-
-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: () => new 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,
-};

package/models/Assignment.js

@@ -1,23 +0,0 @@
-const mongoose = require("mongoose");
-
-const assignmentSchema = new mongoose.Schema({
-  cardId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Card",
-    required: true,
-  },
-  id: {
-    type: String,
-    required: true,
-  },
-  name: {
-    type: String,
-  },
-  email: {
-    type: String,
-  },
-});
-
-const Assignment = mongoose.model("Assignment", assignmentSchema);
-
-module.exports = Assignment;