shuttlepro-shared 1.1.81 → 1.1.82

package/config/redis.js

@@ -1,160 +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);
-    }
-  }
-};
-
-/**
- * ✅ 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;
-  }
-};
-
-/**
- * ✅ 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,
-};

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,189 +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" },
-  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,
-};

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;

package/models/BusinessDistribution.js

@@ -1,23 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const businessDistributionSchema = new mongoose.Schema(
-  {
-    name: { type: String, default: "" },
-    deliveryCharges: { type: String, default: "" },
-    shippers: [],
-    type: {
-      type: String,
-      enum: ["default", "cities"],
-      required: true,
-    },
-    index: { type: String, default: "" },
-    workspaceId: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = mongoose.model(
-  "BusinessDistribution",
-  businessDistributionSchema
-);

package/models/Card.js

@@ -1,144 +0,0 @@
-const mongoose = require("mongoose");
-const { DYNAMIC_FIELD_TYPES } = require("../constants");
-
-const cardSchema = new mongoose.Schema(
-  {
-    cardId: { type: String, required: true },
-    columnId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Column",
-      required: false,
-      default: null,
-      set: (v) => (v === "" ? null : v),
-    },
-    title: {
-      type: String,
-      default: "",
-      // required: true,
-    },
-    description: {
-      type: String,
-    },
-    priority: {
-      type: String,
-      enum: ["high", "medium", "low"],
-    },
-    typeId: [
-      {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Label",
-      },
-    ],
-    type: {
-      type: String,
-      required: true,
-    },
-    assignedBy: {
-      type: Object,
-    },
-    attachmentId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Attachment",
-    },
-    attachments: {
-      type: [String],
-      default: [],
-    },
-    product: {
-      type: Object,
-    },
-    courierId: {
-      type: String,
-    },
-    orderId: {
-      type: Object,
-    },
-    conversation: {
-      type: Object,
-    },
-    deleted: {
-      type: Boolean,
-      default: false,
-    },
-    isExpired: {
-      type: Boolean,
-      default: false,
-    },
-    isUpdated: {
-      type: Boolean,
-      default: false,
-    },
-    completionDate: {
-      type: String,
-    },
-    updatedDate: {
-      type: Date,
-      default: Date.now,
-    },
-    ticketId: {
-      type: Number,
-    },
-    category: {
-      type: String,
-      default: "ticket",
-      enum: ["ticket", "conversation"],
-    },
-    dynamicFieldValue: [
-      {
-        dynamicFieldId: {
-          type: String,
-          default: "",
-        },
-        fieldType: {
-          type: String,
-          enum: DYNAMIC_FIELD_TYPES,
-        },
-        fieldValueId: {
-          type: mongoose.Schema.Types.Mixed,
-        },
-      },
-    ],
-    workspaceId: { type: String, default: "" },
-    activities: [
-      {
-        data: {
-          type: mongoose.Schema.Types.Mixed,
-          default: {},
-        },
-      },
-    ],
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-cardSchema.index({ workspaceId: 1, createdAt: 1 }); // Common filter
-
-// Virtual for the assignedTo user
-cardSchema.virtual("assignedToUser", {
-  ref: "User",
-  localField: "assignedTo",
-  foreignField: "_id",
-});
-
-// Virtual for the attachment
-cardSchema.virtual("attachment", {
-  ref: "Attachment",
-  localField: "attachmentId",
-  foreignField: "_id",
-});
-
-// Virtual for the comment
-cardSchema.virtual("comments", {
-  ref: "CardComment",
-  localField: "_id",
-  foreignField: "cardId",
-});
-
-// Virtual for the assignmentList
-cardSchema.virtual("assignedTo", {
-  ref: "Assignment",
-  localField: "_id", // Change to 'cardId' to match the 'cardId' field in the Assignment model
-  foreignField: "cardId",
-});
-
-module.exports = mongoose.model("Card", cardSchema);