shuttlepro-shared 1.3.14 → 1.3.15

package/common/repositories/user.repository.js

@@ -0,0 +1,150 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+const mongoose = require("mongoose");
+const userSchema = require("../../models/User");
+const User = mongoose.models.User || mongoose.model("User", userSchema);
+
+const CACHE_KEY_ALL_USERS = "users_all";
+
+const getCachedUsers = async () => {
+  try {
+    let users = await getRedisData(CACHE_KEY_ALL_USERS);
+    if (!users) {
+      users = await User.find().lean().exec();
+      await setRedisData(CACHE_KEY_ALL_USERS, users);
+    }
+    return users;
+  } catch (error) {
+    console.error("Error fetching cached users:", error);
+    return [];
+  }
+};
+
+const updateCachedUsers = async () => {
+  try {
+    const users = await User.find().lean().exec();
+    await setRedisData(CACHE_KEY_ALL_USERS, users);
+  } catch (error) {
+    console.error("Error updating cached users:", error);
+  }
+};
+
+const createUser = async (data) => {
+  const newUser = new User(data);
+  const savedUser = await newUser.save();
+  await updateCachedUsers();
+  return savedUser;
+};
+
+const findUserById = async (id, select = []) => {
+  try {
+    let users = await getCachedUsers();
+    let user = users.find((u) => u._id.toString() === id) || null;
+
+    if (!user) {
+      user = await User.findById(id).lean().exec();
+      if (user) await updateCachedUsers(); // Refresh cache if outdated
+    }
+
+    if (user && select.length > 0) {
+      return select.reduce((result, field) => {
+        if (user[field] !== undefined) result[field] = user[field];
+        return result;
+      }, {});
+    }
+    return user;
+  } catch (error) {
+    console.error("Error finding user by ID:", error);
+    return null;
+  }
+};
+
+const findUser = async (filter) => {
+  try {
+    const users = await getCachedUsers();
+    const user = users.find((u) =>
+      Object.entries(filter).every(([key, value]) => {
+        if (Array.isArray(value)) {
+          return value.includes(u[key]);
+        }
+        return u[key] === value;
+      })
+    );
+
+    if (!user) {
+      // Fallback to database if not found in cache
+      const dbUser = await User.findOne(filter).lean().exec();
+      if (dbUser) await updateCachedUsers(); // Refresh cache if outdated
+      return dbUser;
+    }
+
+    return user;
+  } catch (error) {
+    console.error("Error finding user:", error);
+    return null;
+  }
+};
+
+const findUsersByFilter = async (filter = {}) => {
+  try {
+    const users = await getCachedUsers();
+    return users.filter((u) =>
+      Object.entries(filter).every(([key, value]) => {
+        if (Array.isArray(value)) {
+          return value.includes(u[key]);
+        }
+        return u[key] === value;
+      })
+    );
+  } catch (error) {
+    console.error("Error finding users by filter:", error);
+    return [];
+  }
+};
+
+const findAllUsers = async (filter = {}) => {
+  const users = await getCachedUsers();
+  return users.filter((u) =>
+    Object.entries(filter).every(([key, value]) => {
+      if (Array.isArray(value)) {
+        return value.includes(u[key]);
+      }
+      return u[key] === value;
+    })
+  );
+};
+
+const getUserName = async (id) => {
+  const user = await findUserById(id, ["firstName", "lastName"]);
+  return user?.firstName || user?.lastName
+    ? `${user.firstName} ${user.lastName}`.trim()
+    : "Unknown User";
+};
+
+const updateUser = async (id, data) => {
+  const updatedUser = await User.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+  if (updatedUser) {
+    await updateCachedUsers();
+  }
+  return updatedUser;
+};
+
+const deleteUser = async (id) => {
+  const deletedUser = await User.findByIdAndDelete(id).exec();
+  if (deletedUser) {
+    await updateCachedUsers();
+  }
+  return deletedUser;
+};
+
+module.exports = {
+  createUser,
+  findUserById,
+  findUser,
+  findUsersByFilter,
+  findAllUsers,
+  getUserName,
+  updateUser,
+  deleteUser,
+};

package/common/repositories/userPermission.repository.js

@@ -0,0 +1,228 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+const UserPermission = require("../../models/UserPermission");
+
+const CACHE_KEY_ALL = "user_permissions_all";
+
+/**
+ * Get cached user permissions for all users.
+ */
+const getCachedAllUserPermissions = async () => {
+  let permissions = await getRedisData(CACHE_KEY_ALL);
+  if (!permissions) {
+    permissions = await UserPermission.find({}).lean().exec();
+    await setRedisData(CACHE_KEY_ALL, permissions);
+  }
+  return permissions;
+};
+
+/**
+ * Update cached user permissions for all users.
+ */
+const updateCachedAllUserPermissions = async () => {
+  const permissions = await UserPermission.find({}).lean().exec();
+  await setRedisData(CACHE_KEY_ALL, permissions);
+};
+
+/**
+ * Get cached user permissions for a specific user.
+ * Uses the all permissions cache and filters by userId.
+ */
+const getCachedUserPermissions = async (userId) => {
+  const allPermissions = await getCachedAllUserPermissions();
+  return allPermissions.filter((perm) => perm.userId === userId);
+};
+
+/**
+ * Create a new user permission and update cache.
+ */
+const createUserPermission = async (data) => {
+  const newPermission = new UserPermission(data);
+  const savedPermission = await newPermission.save();
+
+  // Update the main cache
+  await updateCachedAllUserPermissions();
+
+  return savedPermission;
+};
+
+/**
+ * Find user permissions by user ID.
+ */
+const findUserPermissionsByUserId = async (userId) => {
+  return await getCachedUserPermissions(userId);
+};
+
+/**
+ * Find user permissions by user ID and workspace ID.
+ */
+const fetchUserPermissionsByWorkspaceId = async (userId, workspaceId) => {
+  const allPermissions = await getCachedAllUserPermissions();
+  return allPermissions.filter(
+    (perm) => perm.userId === userId && perm.workspaceId === workspaceId
+  );
+};
+
+/**
+ * Find a single user permission by filter.
+ */
+const findUserPermission = async (filter, workspaceId = null) => {
+  const allPermissions = await getCachedAllUserPermissions();
+
+  let filteredPermissions = allPermissions;
+  if (workspaceId) {
+    filteredPermissions = allPermissions.filter(
+      (perm) => perm.workspaceId === workspaceId
+    );
+  }
+
+  return (
+    filteredPermissions.find((perm) =>
+      Object.entries(filter).every(([key, value]) => perm[key] === value)
+    ) || null
+  );
+};
+
+/**
+ * Find all user permissions that match a filter.
+ */
+const findAllUserPermissionsByFilter = async (
+  filter = {},
+  workspaceId = null
+) => {
+  const allPermissions = await getCachedAllUserPermissions();
+
+  let filteredPermissions = allPermissions;
+  if (workspaceId) {
+    filteredPermissions = allPermissions.filter(
+      (perm) => perm.workspaceId === workspaceId
+    );
+  }
+
+  return (
+    filteredPermissions.filter((perm) =>
+      Object.entries(filter).every(([key, value]) => perm[key] === value)
+    ) || []
+  );
+};
+
+/**
+ * Find all user permissions (without filtering).
+ */
+const findAllUserPermissions = async () => {
+  return await getCachedAllUserPermissions();
+};
+
+/**
+ * Update a user permission by ID.
+ */
+const updateUserPermission = async (id, data) => {
+  const updatedPermission = await UserPermission.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+
+  if (updatedPermission) {
+    // Update the main cache
+    await updateCachedAllUserPermissions();
+  }
+
+  return updatedPermission;
+};
+
+/**
+ * Update a user permission by filter.
+ */
+const updateUserPermissionByFilter = async (
+  filter,
+  data,
+  workspaceId = null
+) => {
+  // Add workspace filter if provided
+  const queryFilter = workspaceId ? { ...filter, workspaceId } : filter;
+
+  const updatedPermission = await UserPermission.findOneAndUpdate(
+    queryFilter,
+    data,
+    {
+      new: true,
+    }
+  ).exec();
+
+  if (updatedPermission) {
+    // Update the main cache
+    await updateCachedAllUserPermissions();
+  }
+
+  return updatedPermission;
+};
+
+/**
+ * Delete a user permission by ID.
+ */
+const deleteUserPermission = async (id) => {
+  const deletedPermission = await UserPermission.findByIdAndDelete(id).exec();
+
+  if (deletedPermission) {
+    // Update the main cache
+    await updateCachedAllUserPermissions();
+  }
+
+  return deletedPermission;
+};
+
+/**
+ * Delete user permissions by filter.
+ */
+const deleteUserPermissionsByFilter = async (filter) => {
+  const result = await UserPermission.deleteMany(filter).exec();
+
+  if (result.deletedCount > 0) {
+    // Update the main cache
+    await updateCachedAllUserPermissions();
+  }
+
+  return result;
+};
+
+/**
+ * Delete all user permissions for a specific workspace.
+ */
+const deleteAllUserPermissionsByWorkspace = async (workspaceId) => {
+  await UserPermission.deleteMany({ workspaceId }).exec();
+
+  // Update the main cache
+  await updateCachedAllUserPermissions();
+};
+
+/**
+ * Bulk create or update user permissions.
+ */
+const bulkCreateAndUpdateUserPermissions = async (operations) => {
+  await UserPermission.bulkWrite(operations);
+  await updateCachedAllUserPermissions();
+  return operations;
+};
+
+/**
+ * Insert multiple user permissions and update cache.
+ */
+const insertManyUserPermissions = async (permissionsArray) => {
+  const inserted = await UserPermission.insertMany(permissionsArray);
+  await updateCachedAllUserPermissions();
+  return inserted;
+};
+
+module.exports = {
+  createUserPermission,
+  findUserPermission,
+  findUserPermissionsByUserId,
+  fetchUserPermissionsByWorkspaceId,
+  findAllUserPermissionsByFilter,
+  findAllUserPermissions,
+  updateUserPermission,
+  updateUserPermissionByFilter,
+  deleteUserPermission,
+  deleteUserPermissionsByFilter,
+  deleteAllUserPermissionsByWorkspace,
+  bulkCreateAndUpdateUserPermissions,
+  insertManyUserPermissions,
+};

package/common/repositories/userRepository.js

@@ -0,0 +1,31 @@
+const User = require("../../models/User");
+
+const createUser = async (data) => {
+  const newUser = new User(data);
+  const savedUser = await newUser.save();
+  return savedUser;
+};
+
+const findUser = async (filter) => {
+  return await User.findOne(filter).exec();
+};
+
+const updateUser = async (id, data) => {
+  const updatedUser = await User.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+
+  return updatedUser;
+};
+
+const deleteUser = async (id) => {
+  const deletedUser = await User.findByIdAndDelete(id).exec();
+  return deletedUser;
+};
+
+module.exports = {
+  createUser,
+  findUser,
+  updateUser,
+  deleteUser,
+};

package/common/repositories/userRole.repository.js

@@ -0,0 +1,235 @@
+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";
+
+// Cache keys
+const MEMBERS = "members";
+
+// Update the cache for all members
+const updateCachedMembers = async (workspaceId) => {
+  try {
+    const members = await UserRole.find({ workspaceId })
+      .select("userId role userShift roleId isOwner workspaceId")
+      .populate({
+        path: "roleId",
+        select:
+          "id name userId userShift permissionId modulePermissions workspaceId",
+        populate: [{ path: "permissionId", select: "id name" }],
+      })
+      .populate({
+        path: "userId",
+        match: { isDeleted: false, suspended: false },
+        select: "firstName lastName role email picture userShift",
+      })
+      .lean()
+      .exec();
+    await setRedisData(workspaceId, members, MEMBERS, 3600);
+    return members;
+  } catch (error) {
+    console.error("Error updating cached members:", error);
+    return [];
+  }
+};
+
+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")
+      .populate({
+        path: "roleId",
+        select:
+          "id name userId userShift permissionId modulePermissions workspaceId",
+        populate: [{ path: "permissionId", select: "id name" }],
+      })
+      .populate({
+        path: "userId",
+        match: { isDeleted: false, suspended: false },
+        select: "firstName lastName role email picture userShift",
+      })
+      .lean()
+      .exec();
+    await setRedisData(workspaceId, members, MEMBERS, 3600);
+  }
+  return members;
+};
+
+const getMemberByWorkspaceIdAndUserId = async (workspaceId, userId) => {
+  const members = await getMembers(workspaceId);
+  return (
+    members?.find(
+      (member) =>
+        member?.workspaceId === workspaceId && member?.userId?._id === userId
+    ) || null
+  );
+};
+
+// Find single user role by filter
+const findSingleUserRoleByFilter = async ({ workspaceId, userId }) => {
+  return await getMemberByWorkspaceIdAndUserId(workspaceId, userId);
+};
+
+const findAllUserRoles = async (workspaceId) => {
+  return await getMembers(workspaceId);
+};
+
+const createUserRole = async (data) => {
+  const savedRole = await UserRole.create(data);
+  return await updateCachedMembers(savedRole?.workspaceId?.toString());
+};
+
+const findOneAndUpdateUserRole = async (filter, payload) => {
+  await UserRole.findOneAndUpdate(
+    filter,
+    { $set: payload },
+    { new: true, upsert: false }
+  )
+    .lean()
+    .exec();
+  return await updateCachedMembers(filter.workspaceId);
+};
+
+const updateUserRole = async (filter, payload) => {
+  await UserRole.updateOne(filter, payload).exec();
+  return await updateCachedMembers(filter.workspaceId);
+};
+
+// Update multiple user roles based on filter
+const updateManyUserRoles = async (filter, payload) => {
+  await UserRole.updateMany(filter, { $set: payload }).exec();
+  return await updateCachedMembers(filter.workspaceId);
+};
+
+const deleteUserRoleByFilter = async (filter) => {
+  await UserRole.deleteOne(filter).exec();
+  return await updateCachedMembers(filter.workspaceId);
+};
+
+const convertPermissionsArrayToObject = (originalArray) => {
+  return originalArray?.reduce((acc, item) => {
+    const { id, actions, integrationPermissions, ...extras } = item;
+    const formattedExtras = {};
+    if (extras.deletable !== undefined) {
+      formattedExtras.deletable = extras.deletable;
+    }
+    if (extras.createUpdateable !== undefined) {
+      formattedExtras.createUpdateable = extras.createUpdateable;
+    }
+    acc[id] = {
+      actions: Object.keys(actions).filter((action) => actions[action]),
+      ...formattedExtras,
+      ...(integrationPermissions && {
+        integrationPermissions: Object.entries(integrationPermissions)
+          .filter(([_, allowed]) => allowed)
+          .map(([key]) => key),
+      }),
+    };
+    return acc;
+  }, {});
+};
+
+const getUserPermissions = async (workspaceId, userId) => {
+  try {
+    let data = await getMemberByWorkspaceIdAndUserId(workspaceId, userId);
+    if (data) {
+      return (
+        convertPermissionsArrayToObject(
+          data?.roleId?.modulePermissions?.modules
+        ) || null
+      );
+    }
+    return null;
+  } catch (err) {
+    console.error("Error in getUserPermissions:", err);
+    return null;
+  }
+};
+
+const getUserRoleWithPermissions = async (workspaceId, userId) => {
+  try {
+    let data = await getMemberByWorkspaceIdAndUserId(workspaceId, userId);
+    if (data) {
+      const roleWithPermissions = {
+        ...data,
+        roleId: data?.roleId?._id?.toString() || "",
+        role: data?.roleId?.name || "",
+        permissions:
+          convertPermissionsArrayToObject(
+            data?.roleId?.modulePermissions?.modules
+          ) || [],
+        parentRole: data?.roleId?.permissionId?.name || "",
+        parentRoleId: data?.roleId?.permissionId?._id?.toString() || "",
+        defaultModule: data?.roleId?.defaultModule || "",
+      };
+      return roleWithPermissions || null;
+    }
+    return null;
+  } catch (err) {
+    console.error("Error in getUserRoleWithPermissions:", err);
+    return null;
+  }
+};
+
+const getChannelsPermissions = async (workspaceId, userId) => {
+  try {
+    let data = await getMemberByWorkspaceIdAndUserId(workspaceId, userId);
+    if (data) {
+      return (
+        convertPermissionsArrayToObject(
+          data?.roleId?.modulePermissions?.modules
+        )?.["conversations"]?.["integrationPermissions"] || []
+      );
+    }
+    return [];
+  } catch (err) {
+    console.error("Error in getChannelsPermissions:", err);
+    return [];
+  }
+};
+
+const findUserWorkspaces = async (userId) => {
+  let userRoleWithWorkspaces = await UserRole.find({ userId: userId })
+    .select("userId roleId workspaceId")
+    .populate({
+      path: "roleId",
+      select: "id name userId userShift permissionId modulePermissions",
+      populate: [{ path: "permissionId", select: "id name" }],
+    })
+    .populate({
+      path: "workspaceId",
+      select: defaultSelect,
+      match: { isDeleted: false },
+    })
+    .lean()
+    .exec();
+  userRoleWithWorkspaces = userRoleWithWorkspaces
+    ?.filter((userRole) => userRole?.workspaceId)
+    ?.filter((userRole) => userRole?.roleId)
+    ?.map((ur) => {
+      return {
+        ...ur?.workspaceId,
+        id: ur?.workspaceId?._id?.toString(),
+        _id: ur?.workspaceId?._id?.toString(),
+        role: ur?.roleId?.name || "",
+        permissions: ur?.roleId?.modulePermissions?.modules || [],
+      };
+    });
+  return userRoleWithWorkspaces || [];
+};
+
+module.exports = {
+  createUserRole,
+  updateUserRole,
+  updateManyUserRoles,
+  findAllUserRoles,
+  deleteUserRoleByFilter,
+  findUserWorkspaces,
+  getUserRoleWithPermissions,
+  getUserPermissions,
+  getChannelsPermissions,
+  findOneAndUpdateUserRole,
+  findSingleUserRoleByFilter,
+  updateCachedMembers,
+};

package/common/repositories/userRolePermission.repository.js

@@ -0,0 +1,59 @@
+const DefaultRolePermission = require("../../models/DefaultRolePermission");
+
+const createDefaultRolePermission = async (data) => {
+  const newPermission = new DefaultRolePermission(data);
+  const savedPermission = await newPermission.save();
+  return savedPermission;
+};
+
+const findDefaultRolePermission = async (filter) => {
+  return await DefaultRolePermission.findOne(filter).exec();
+};
+
+const findAllDefaultRolePermissions = async (filter = {}) => {
+  return await DefaultRolePermission.find(filter).exec();
+};
+
+const updateDefaultRolePermission = async (id, data) => {
+  const updatedPermission = await DefaultRolePermission.findByIdAndUpdate(
+    id,
+    data,
+    {
+      new: true,
+    }
+  ).exec();
+  return updatedPermission;
+};
+
+const deleteDefaultRolePermission = async (id) => {
+  const deletedPermission = await DefaultRolePermission.findByIdAndDelete(
+    id
+  ).exec();
+  return deletedPermission;
+};
+
+const deleteDefaultRolePermissionsByFilter = async (filter) => {
+  const deleted = await DefaultRolePermission.deleteMany(filter).exec();
+  return deleted;
+};
+
+const deleteOneDefaultRolePermissionByFilter = async (filter) => {
+  const deleted = await DefaultRolePermission.findOneAndDelete(filter).exec();
+  return deleted;
+};
+
+const insertManyUserPermissions = async (permissionsArray) => {
+  const inserted = await UserPermission.insertMany(permissionsArray);
+  return inserted;
+};
+
+module.exports = {
+  createDefaultRolePermission,
+  findDefaultRolePermission,
+  findAllDefaultRolePermissions,
+  updateDefaultRolePermission,
+  deleteDefaultRolePermission,
+  deleteDefaultRolePermissionsByFilter,
+  deleteOneDefaultRolePermissionByFilter,
+  insertManyUserPermissions,
+};