shuttlepro-shared 1.3.14 → 1.3.16

package/common/repositories/label.repository.js

@@ -0,0 +1,95 @@
+const Label = require("../../models/Label");
+const {
+  setRedisData,
+  getRedisData,
+  deleteRedisData,
+} = require("../../config/redis");
+
+const CACHE_KEYS = {
+  ALL_LABELS: "labels:all",
+  WORKSPACE_LABELS: (workspaceId) => `labels:workspace:${workspaceId}`,
+  LABEL_DETAILS: (labelId) => `labels:details:${labelId}`,
+};
+
+const CACHE_EXPIRY = 60 * 60; // 1 hour
+
+// Utility function for caching
+const withCache = async (cacheKey, fetchFn, forceFresh = false) => {
+  if (!forceFresh) {
+    const cachedData = await getRedisData(cacheKey);
+    if (cachedData) return cachedData;
+  }
+
+  const data = await fetchFn();
+  if (data && data.length) {
+    await setRedisData(cacheKey, data, null, CACHE_EXPIRY);
+  }
+
+  return data;
+};
+
+// Core functions
+const createLabel = async (labelData) => {
+  const existingLabels = await Label.find();
+  const isDuplicate = existingLabels.some(
+    (label) =>
+      label.title.toLowerCase() === labelData.title.toLowerCase() &&
+      label.workspaceId === labelData.workspaceId
+  );
+
+  if (isDuplicate) throw new Error("Label with this title already exists");
+
+  const newLabel = new Label(labelData);
+  return await newLabel.save();
+};
+
+const findLabels = async (query = {}, options = {}) => {
+  return await withCache(JSON.stringify(query), () =>
+    Label.find(query)
+      .sort({ createdAt: -1 })
+      .limit(options.limit || 100)
+      .exec()
+  );
+};
+
+const findAllLabels = async (query = {}) => {
+  return await withCache(JSON.stringify(query), () => Label.find(query).exec());
+};
+
+const findLabelById = async (labelId) => {
+  return await withCache(CACHE_KEYS.LABEL_DETAILS(labelId), () =>
+    Label.findById(labelId).exec()
+  );
+};
+
+const findLabel = async (query = {}) => {
+  return await Label.findOne(query).exec();
+};
+
+const updateLabel = async (labelId, updateData) => {
+  const updatedLabel = await Label.findByIdAndUpdate(labelId, updateData, {
+    new: true,
+  });
+  await setRedisData(
+    CACHE_KEYS.LABEL_DETAILS(labelId),
+    updatedLabel.toObject(),
+    null,
+    CACHE_EXPIRY
+  );
+  return updatedLabel;
+};
+
+const deleteLabel = async (labelId) => {
+  await deleteRedisData(CACHE_KEYS.LABEL_DETAILS(labelId));
+  return await Label.findByIdAndDelete(labelId);
+};
+
+module.exports = {
+  createLabel,
+  findLabels,
+  findAllLabels,
+  findLabelById,
+  findLabel,
+  updateLabel,
+  deleteLabel,
+};

package/common/repositories/notificationSettings.repository.js

@@ -0,0 +1,95 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+
+const NotificationSettings = require("../../models/NotificationSettings");
+
+const getNotificationFromCache = async (workspaceId, userId) => {
+  let notificationSettings = await getRedisData(
+    `notificationSettings-${userId}`
+  );
+  if (!notificationSettings) {
+    notificationSettings = await NotificationSettings.findOne({
+      workspaceId,
+      createdBy: userId,
+    });
+    await setRedisData(`notificationSettings-${userId}`, notificationSettings);
+  }
+  return notificationSettings;
+};
+const getUserNotificationSettings = async (workspaceId, userId) => {
+  return await getNotificationFromCache(workspaceId, userId);
+};
+
+const defaultNotifications = async (workspaceId, userId = null) => {
+  try {
+    const obj = {
+      workspaceId: workspaceId,
+      products: true,
+      orders: {
+        createOrder: true,
+        orderAssign: true,
+        orderComment: true,
+      },
+      default: true,
+      conversation: {
+        instaMessage: true,
+        fbMessage: true,
+        instaComment: true,
+        fbComment: true,
+        email: true,
+        whatsapp: true,
+      },
+      socialProfiles: {
+        socialProfileComment: true,
+        story: true,
+      },
+      taskManager: {
+        cardAssign: true,
+        cardMove: true,
+      },
+      sound: {
+        play: true,
+      },
+      createdBy: userId,
+    };
+    return await NotificationSettings.create(obj);
+  } catch (err) {
+    console.log(err, "err");
+    return null;
+  }
+};
+const updateUserNotificationSettings = async (body, userId) => {
+  try {
+    const { type } = body;
+    let { value } = body;
+
+    if (type === "default" || type === "products") {
+      value = value?.all || false;
+    } else {
+      delete value?.all;
+    }
+    let notificationSettings = await NotificationSettings.findOne({
+      workspaceId: body.workspaceId,
+      createdBy: userId,
+    });
+
+    if (notificationSettings) {
+      notificationSettings[type] = value;
+      const updatedSettings = await notificationSettings.save();
+      await setRedisData(`notificationSettings-${userId}`, updatedSettings);
+      return updatedSettings;
+    } else {
+      const newSettings = await defaultNotifications(body.workspaceId, userId);
+
+      await setRedisData(`notificationSettings-${userId}`, newSettings);
+      return newSettings;
+    }
+  } catch (error) {
+    console.log(error, "err");
+    return null;
+  }
+};
+module.exports = {
+  getUserNotificationSettings,
+  updateUserNotificationSettings,
+  defaultNotifications,
+};

package/common/repositories/role.repository.js

@@ -0,0 +1,333 @@
+const Role = require("../../models/Role");
+const { getRedisData, setRedisData } = require("../../config/redis");
+
+// Cache keys
+const ROLES = "roles";
+const DEFAULT_ROLES = "default_roles";
+const CACHE_TIME = 3600 * 2;
+
+// Update the cache for workspace roles
+const updateCachedRoles = async (workspaceId) => {
+  try {
+    const roles = await Role.find({ workspaceId })
+      .populate("permissionId")
+      .lean()
+      .exec();
+    await setRedisData(workspaceId, roles, ROLES, CACHE_TIME);
+    return roles;
+  } catch (error) {
+    console.error("Error updating cached roles:", error);
+    return [];
+  }
+};
+
+// Get roles from cache or database for a specific workspace
+const getRoles = async (workspaceId) => {
+  let roles = await getRedisData(workspaceId, ROLES);
+  if (!roles || roles?.length === 0) {
+    roles = await Role.find({ workspaceId })
+      .populate("permissionId")
+      .lean()
+      .exec();
+    await setRedisData(workspaceId, roles, ROLES, CACHE_TIME);
+  }
+  return roles;
+};
+
+// Update default roles cache (system-wide roles with no workspace)
+const updateCachedDefaultRoles = async () => {
+  try {
+    const data = await Role.find({ name: { $ne: "super" }, workspaceId: null })
+      .select("name")
+      .sort({ _id: -1 })
+      .lean()
+      .exec();
+
+    const defaultRoles = data.map((d) => {
+      return {
+        id: d?._id,
+        name: d?.name,
+      };
+    });
+
+    await setRedisData("system", defaultRoles, DEFAULT_ROLES, CACHE_TIME);
+    return defaultRoles;
+  } catch (error) {
+    console.error("Error updating cached default roles:", error);
+    return [];
+  }
+};
+
+// Get default roles from cache or database
+const getDefaultRoles = async () => {
+  let defaultRoles = await getRedisData("system", DEFAULT_ROLES);
+  if (!defaultRoles || defaultRoles?.length === 0) {
+    const data = await Role.find({ name: { $ne: "super" }, workspaceId: null })
+      .select("name")
+      .sort({ _id: -1 })
+      .lean()
+      .exec();
+
+    defaultRoles = data.map((d) => {
+      return {
+        id: d?._id,
+        name: d?.name,
+      };
+    });
+
+    await setRedisData("system", defaultRoles, DEFAULT_ROLES, CACHE_TIME);
+  }
+  return defaultRoles;
+};
+
+const createRole = async (roleData) => {
+  const newRole = await Role.create(roleData);
+  const createdRole = await Role.findById(newRole._id)
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (createdRole.workspaceId) {
+    await updateCachedRoles(createdRole.workspaceId);
+  } else {
+    // If it's a default/system role
+    await updateCachedDefaultRoles();
+  }
+
+  return createdRole;
+};
+
+const findRoleById = async (id, workspaceId) => {
+  const roles = await getRoles(workspaceId);
+  const role = roles.find((r) => r._id.toString() === id);
+
+  if (role) return role;
+
+  // If not found in cache, query directly
+  const freshRole = await Role.findById(id)
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (freshRole && freshRole.workspaceId?.toString() === workspaceId) {
+    // Update the cache with the new data
+    await updateCachedRoles(workspaceId);
+  }
+  return freshRole;
+};
+
+const findSingleRole = async (filter) => {
+  const workspaceId = filter.workspaceId;
+  if (workspaceId) {
+    const roles = await getRoles(workspaceId);
+    const role = roles.find((r) =>
+      Object.entries(filter).every(([key, value]) => r[key] === value)
+    );
+
+    if (role) return role;
+  }
+
+  // If not found in cache or no workspaceId provided, query directly
+  const freshRole = await Role.findOne(filter)
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (freshRole && freshRole.workspaceId) {
+    // Update the cache with the new data
+    await updateCachedRoles(freshRole.workspaceId);
+  }
+  return freshRole;
+};
+
+const findRolesByPagination = async (body) => {
+  let { page, limit, workspaceId, query, status } = body;
+
+  page = parseInt(page, 10) || 1;
+  limit = parseInt(limit, 10) || 10;
+
+  const skip = (page - 1) * limit;
+
+  let obj = { workspaceId };
+  if (query) {
+    obj.name = { $regex: query, $options: "i" };
+  }
+  if (status) {
+    obj.status = status;
+  }
+
+  const totalRoles = await Role.countDocuments(obj);
+  const totalPages = Math.ceil(totalRoles / limit);
+
+  const roles = await Role.find(obj)
+    .sort({ _id: -1 })
+    .skip(skip)
+    .limit(limit)
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  return {
+    totalPages,
+    currentPage: page,
+    roles,
+  };
+};
+
+const findRoles = async (workspaceId) => {
+  return await getRoles(workspaceId);
+};
+
+const findDefaultRoles = async () => {
+  return await getDefaultRoles();
+};
+
+const updateRoleById = async (id, updateData) => {
+  const updateQuery = {
+    ...updateData,
+    ...(Array.isArray(updateData.logs) && {
+      $push: { logs: { $each: updateData.logs } },
+    }),
+  };
+  delete updateQuery.logs;
+  const updatedRole = await Role.findByIdAndUpdate(id, updateQuery, {
+    new: true,
+  })
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (updatedRole) {
+    await updateCachedRoles(updatedRole?.workspaceId);
+  }
+  return updatedRole;
+};
+
+const updateRoleByFilter = async (filter, updateData) => {
+  const updatedRole = await Role.findOneAndUpdate(filter, updateData, {
+    new: true,
+  })
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (updatedRole?.workspaceId) {
+    await updateCachedRoles(updatedRole?.workspaceId?.toString());
+  }
+  return updatedRole;
+};
+
+const updateRolesByFilter = async (filter, updateData) => {
+  const result = await Role.updateMany(filter, updateData, { new: true });
+  if (result.matchedCount > 0) {
+    if (filter.workspaceId) {
+      await updateCachedRoles(filter.workspaceId);
+    } else {
+      if (!filter.workspaceId || filter.workspaceId === null) {
+        await updateCachedDefaultRoles();
+      }
+    }
+  }
+  return result;
+};
+
+const addLogToRole = async (id, logData) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $push: { logs: logData } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
+  }
+  return updatedRole;
+};
+
+const clearRoleLogs = async (id) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $set: { logs: [] } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
+  }
+  return updatedRole;
+};
+
+const addPermissionToRole = async (id, permission) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $push: { permissions: permission } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
+  }
+  return updatedRole;
+};
+
+const removePermissionFromRole = async (id, permission) => {
+  const role = await Role.findById(id).lean().exec();
+  const workspaceId = role?.workspaceId;
+
+  const updatedRole = await Role.findByIdAndUpdate(
+    id,
+    { $pull: { permissions: permission } },
+    { new: true }
+  )
+    .populate("permissionId")
+    .lean()
+    .exec();
+
+  if (updatedRole && workspaceId) {
+    await updateCachedRoles(workspaceId);
+  }
+
+  return updatedRole;
+};
+
+const deleteRoleById = async (id, workspaceId) => {
+  return await Role.deleteOne({ _id: id }).exec();
+};
+
+const deleteSingleRole = async (filter) => {
+  return await Role.deleteOne(filter).exec();
+};
+
+const deleteManyRoles = async (filter) => {
+  return await Role.deleteMany(filter);
+};
+
+module.exports = {
+  createRole,
+  findRoleById,
+  findSingleRole,
+  findRoles,
+  updateRoleById,
+  updateRoleByFilter,
+  updateRolesByFilter,
+  addLogToRole,
+  clearRoleLogs,
+  addPermissionToRole,
+  removePermissionFromRole,
+  deleteRoleById,
+  deleteSingleRole,
+  deleteManyRoles,
+  findRolesByPagination,
+  findDefaultRoles,
+  updateCachedRoles,
+  updateCachedDefaultRoles,
+};

package/common/repositories/settings.repository.js

@@ -0,0 +1,32 @@
+const Setting = require("../../models/Setting");
+
+const createSetting = async (data) => {
+  const newSetting = new Setting(data);
+  const savedSetting = await newSetting.save();
+  return savedSetting;
+};
+
+const findSetting = async (filter) => {
+  return await Setting.findOne(filter).exec();
+};
+
+const updateSetting = async (id, data) => {
+  const updatedSetting = await Setting.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+
+  return updatedSetting;
+};
+
+const deleteSetting = async (id) => {
+  const deletedSetting = await Setting.findByIdAndDelete(id).exec();
+
+  return deletedSetting;
+};
+
+module.exports = {
+  createSetting,
+  findSetting,
+  updateSetting,
+  deleteSetting,
+};

package/common/repositories/shipper.repository.js

@@ -0,0 +1,77 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+const Shipper = require("../../models/Shipper");
+
+const CACHE_KEY_ALL = "shippers_all";
+
+const getCachedShippers = async () => {
+  let shippers = await getRedisData(CACHE_KEY_ALL);
+  if (!shippers) {
+    shippers = await Shipper.find().lean().exec();
+    await setRedisData(CACHE_KEY_ALL, JSON.stringify(shippers));
+  } else {
+    shippers = JSON.parse(shippers);
+  }
+  return shippers;
+};
+
+const updateCachedShippers = async () => {
+  const shippers = await Shipper.find().lean().exec();
+  await setRedisData(CACHE_KEY_ALL, JSON.stringify(shippers));
+};
+
+const createShipper = async (data) => {
+  const newShipper = new Shipper(data);
+  const savedShipper = await newShipper.save();
+  await updateCachedShippers();
+  return savedShipper;
+};
+
+const findShipperById = async (id) => {
+  const shippers = await getCachedShippers();
+  const shipper = shippers.find((s) => s._id.toString() === id) || null;
+
+  return shipper;
+};
+
+const findShipper = async (filter) => {
+  const shippers = await getCachedShippers();
+  return (
+    shippers.find((s) =>
+      Object.entries(filter).every(([key, value]) => s[key] === value)
+    ) || null
+  );
+};
+
+const findAllShippers = async (filter = {}) => {
+  const shippers = await getCachedShippers();
+  return shippers.filter((s) =>
+    Object.entries(filter).every(([key, value]) => s[key] === value)
+  );
+};
+
+const updateShipper = async (id, data) => {
+  const updatedShipper = await Shipper.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+  if (updatedShipper) {
+    await updateCachedShippers();
+  }
+  return updatedShipper;
+};
+
+const deleteShipper = async (id) => {
+  const deletedShipper = await Shipper.findByIdAndDelete(id).exec();
+  if (deletedShipper) {
+    await updateCachedShippers();
+  }
+  return deletedShipper;
+};
+
+module.exports = {
+  createShipper,
+  findShipperById,
+  findShipper,
+  findAllShippers,
+  updateShipper,
+  deleteShipper,
+};

package/common/repositories/socialMediaSetting.repository.js

@@ -0,0 +1,33 @@
+const SocialMediaSetting = require("../../models/SocialMediaSetting");
+
+const createSocialMediaSetting = async (data) => {
+  const setting = new SocialMediaSetting(data);
+  const saved = await setting.save();
+
+  return saved;
+};
+
+const findSocialMediaSetting = async (filter = {}) => {
+  return await SocialMediaSetting.findOne(filter).exec();
+};
+
+const updateSocialMediaSetting = async (id, data) => {
+  const updated = await SocialMediaSetting.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+
+  return updated;
+};
+
+const deleteSocialMediaSetting = async (id) => {
+  const deleted = await SocialMediaSetting.findByIdAndDelete(id).exec();
+
+  return deleted;
+};
+
+module.exports = {
+  createSocialMediaSetting,
+  findSocialMediaSetting,
+  updateSocialMediaSetting,
+  deleteSocialMediaSetting,
+};