shuttlepro-shared 1.3.13 → 1.3.14

package/common/repositories/userPermission.repository.js

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

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

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

@@ -1,59 +0,0 @@
-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,
-};

package/common/repositories/workspace.repository.js

@@ -1,147 +0,0 @@
-const { getRedisData, setRedisData } = require("../../config/redis");
-const Workspace = require("../../models/Workspace");
-
-const CACHE_KEY_ALL = "workspaces_all";
-
-const getCachedWorkspaces = async () => {
-  let workspaces = await getRedisData(CACHE_KEY_ALL);
-  if (!workspaces) {
-    workspaces = await Workspace.find().lean().exec();
-    await setRedisData(CACHE_KEY_ALL, workspaces);
-  } else {
-    workspaces = workspaces;
-  }
-  return workspaces;
-};
-
-const updateCachedWorkspaces = async () => {
-  const workspaces = await Workspace.find().lean().exec();
-  await setRedisData(CACHE_KEY_ALL, workspaces);
-};
-
-const createWorkspace = async (data) => {
-  const newWorkspace = new Workspace(data);
-  const savedWorkspace = await newWorkspace.save();
-  await updateCachedWorkspaces();
-  return savedWorkspace;
-};
-
-const findWorkspaceById = async (id, select = []) => {
-  const workspaces = await getCachedWorkspaces();
-  const workspace =
-    workspaces.find((ws) => ws._id.toString() === id && !ws?.isDeleted) || null;
-  if (workspace && select.length > 0) {
-    return select.reduce((result, field) => {
-      if (workspace[field] !== undefined) {
-        result[field] = workspace[field];
-      }
-      return result;
-    }, {});
-  }
-  return workspace;
-};
-
-const findWorkspace = async (filter) => {
-  const workspaces = await getCachedWorkspaces();
-  return (
-    workspaces.find((ws) =>
-      Object.entries(filter).every(([key, value]) => ws[key] === value)
-    ) || null
-  );
-};
-
-const findSingleWorkspace = async (filter) => {
-  const cachedWorkspaces = await getCachedWorkspaces();
-  const cachedWorkspace = cachedWorkspaces.find((ws) =>
-    Object.entries(filter).every(([key, value]) => ws[key] === value)
-  );
-  if (cachedWorkspace) return cachedWorkspace;
-  const workspace = await Workspace.findOne(filter).lean().exec();
-  return workspace;
-};
-
-const findWorkspaceByIdAndQueueTracking = async (id) => {
-  const workspaces = await getCachedWorkspaces();
-  return (
-    workspaces.find((ws) => ws._id.toString() === id && ws.queueTracking) ||
-    null
-  );
-};
-
-const findAllWorkspaces = async (filter = {}) => {
-  const workspaces = await getCachedWorkspaces();
-  return workspaces.filter((ws) =>
-    Object.entries(filter).every(([key, value]) => ws[key] === value)
-  );
-};
-const updateWorkspaceCache = async (id = "") => {
-  const workspace = await Workspace.findById(id).lean().exec();
-  await updateCachedWorkspaces();
-  return workspace;
-};
-
-const updateWorkspace = async (id, data) => {
-  const updatedWorkspace = await Workspace.findByIdAndUpdate(id, data, {
-    new: true,
-  }).exec();
-
-  if (updatedWorkspace) {
-    await updateCachedWorkspaces();
-  }
-  return updatedWorkspace;
-};
-
-const updateOneWorkspace = async (filter, update, options = {}) => {
-  const result = await Workspace.updateOne(filter, update, options).exec();
-  if (result.matchedCount > 0) {
-    await updateCachedWorkspaces();
-  }
-  return result;
-};
-
-const updateManyWorkspaces = async (filter, update, options = {}) => {
-  const result = await Workspace.updateMany(filter, update, options).exec();
-  if (result.matchedCount > 0) {
-    await updateCachedWorkspaces();
-  }
-  return result;
-};
-
-const findOneAndUpdateWorkspace = async (
-  filter,
-  update,
-  options = { new: true }
-) => {
-  const updatedWorkspace = await Workspace.findOneAndUpdate(
-    filter,
-    update,
-    options
-  ).exec();
-  if (updatedWorkspace) {
-    await updateCachedWorkspaces();
-  }
-  return updatedWorkspace;
-};
-
-const deleteWorkspace = async (id) => {
-  const deletedWorkspace = await Workspace.findByIdAndDelete(id).exec();
-  if (deletedWorkspace) {
-    await updateCachedWorkspaces();
-  }
-  return deletedWorkspace;
-};
-
-module.exports = {
-  createWorkspace,
-  findWorkspace,
-  findSingleWorkspace,
-  findWorkspaceById,
-  findWorkspaceByIdAndQueueTracking,
-  findAllWorkspaces,
-  findOneAndUpdateWorkspace,
-  updateWorkspace,
-  updateOneWorkspace,
-  updateManyWorkspaces,
-  deleteWorkspace,
-  updateWorkspaceCache,
-};