shuttlepro-shared 1.3.19 → 1.3.20

package/common/repositories/chatMember.repository.js

@@ -0,0 +1,9 @@
+const ChatMember = require("../../models/ChatMember");
+
+const findChatMemberById = async (id) => {
+  return await ChatMember.findById(id).select("userName phoneNo email");
+};
+
+module.exports = {
+  findChatMemberById,
+};

package/common/repositories/customerProfile.repository.js

@@ -0,0 +1,147 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+const CustomerProfile = require("../../models/CustomerProfile");
+
+const CACHE_KEY_ALL = "customer_profiles_all";
+
+const getCachedAllCustomerProfiles = async () => {
+  let profiles = await getRedisData(CACHE_KEY_ALL);
+  if (!profiles) {
+    profiles = await CustomerProfile.find({}).lean().exec();
+    await setRedisData(CACHE_KEY_ALL, profiles);
+  }
+  return profiles;
+};
+
+const updateCachedAllCustomerProfiles = async () => {
+  const profiles = await CustomerProfile.find({}).lean().exec();
+  await setRedisData(CACHE_KEY_ALL, profiles);
+};
+
+const getCachedCustomerProfiles = async (workspaceId) => {
+  const allProfiles = await getCachedAllCustomerProfiles();
+  return allProfiles.filter((profile) => profile.workspaceId === workspaceId);
+};
+
+const createCustomerProfile = async (data) => {
+  const newProfile = new CustomerProfile(data);
+  const savedProfile = await newProfile.save();
+
+  updateCachedAllCustomerProfiles();
+  return savedProfile;
+};
+
+const findCustomerProfilesByWorkspaceId = async (workspaceId) => {
+  return await getCachedCustomerProfiles(workspaceId);
+};
+
+const findCustomerProfilesByWorkspace = async (workspaceId, filter = {}) => {
+  const profiles = await getCachedCustomerProfiles(workspaceId);
+  return profiles.filter((profile) =>
+    Object.entries(filter).every(([key, value]) => profile[key] === value)
+  );
+};
+
+const findCustomerProfileByFilter = async (
+  filter = {},
+  bodyFilter = {},
+  workspaceId = null
+) => {
+  const allProfiles = await getCachedAllCustomerProfiles();
+
+  const filtered = workspaceId
+    ? allProfiles.filter((p) => p.workspaceId === workspaceId)
+    : allProfiles;
+
+  return (
+    filtered.find(
+      (profile) =>
+        Object.entries(filter).every(
+          ([key, value]) => profile[key] === value
+        ) &&
+        Object.entries(bodyFilter).every(
+          ([key, value]) => profile.body?.[key] === value
+        )
+    ) || null
+  );
+};
+
+const findAllCustomerProfilesByFilter = async (
+  filter = {},
+  bodyFilter = {},
+  workspaceId = null
+) => {
+  const allProfiles = await getCachedAllCustomerProfiles();
+
+  const filtered = workspaceId
+    ? allProfiles.filter((p) => p.workspaceId === workspaceId)
+    : allProfiles;
+
+  return (
+    filtered.filter(
+      (profile) =>
+        Object.entries(filter).every(
+          ([key, value]) => profile[key] === value
+        ) &&
+        Object.entries(bodyFilter).every(
+          ([key, value]) => profile.body?.[key] === value
+        )
+    ) || []
+  );
+};
+
+const updateCustomerProfile = async (id, data) => {
+  const updated = await CustomerProfile.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+
+  if (updated) {
+    updateCachedAllCustomerProfiles();
+  }
+
+  return updated;
+};
+
+const updateCustomerProfileByFilter = async (
+  filter,
+  data,
+  workspaceId = null
+) => {
+  const query = workspaceId ? { ...filter, workspaceId } : filter;
+
+  const updated = await CustomerProfile.findOneAndUpdate(query, data, {
+    new: true,
+  }).exec();
+
+  if (updated) {
+    updateCachedAllCustomerProfiles();
+  }
+
+  return updated;
+};
+
+const deleteCustomerProfile = async (id) => {
+  const deleted = await CustomerProfile.findByIdAndDelete(id).exec();
+
+  if (deleted) {
+    updateCachedAllCustomerProfiles();
+  }
+
+  return deleted;
+};
+
+const deleteAllCustomerProfilesByWorkspace = async (workspaceId) => {
+  await CustomerProfile.deleteMany({ workspaceId }).exec();
+  await updateCachedAllCustomerProfiles();
+};
+
+module.exports = {
+  createCustomerProfile,
+  findCustomerProfilesByWorkspaceId,
+  findCustomerProfilesByWorkspace,
+  findCustomerProfileByFilter,
+  updateCustomerProfile,
+  updateCustomerProfileByFilter,
+  deleteCustomerProfile,
+  deleteAllCustomerProfilesByWorkspace,
+  findAllCustomerProfilesByFilter,
+};

package/common/repositories/customerTimeline.repository.js

@@ -0,0 +1,78 @@
+const CustomerTimeline = require("../../models/CustomerTimeline");
+
+const createCustomerTimeline = async (data) => {
+  const newTimeline = new CustomerTimeline(data);
+  return await newTimeline.save();
+};
+
+const findCustomerTimelinesByWorkspaceId = async (workspaceId) => {
+  return await CustomerTimeline.find({ workspaceId }).lean().exec();
+};
+
+const findCustomerTimelinesByWorkspace = async (workspaceId, filter = {}) => {
+  return await CustomerTimeline.find({ workspaceId, ...filter })
+    .lean()
+    .exec();
+};
+
+const findCustomerTimelineByFilter = async (filter = {}, bodyFilter = {}) => {
+  const all = await CustomerTimeline.find(filter).lean().exec();
+
+  return (
+    all.find((item) =>
+      Object.entries(bodyFilter).every(
+        ([key, value]) => item.body?.[key] === value
+      )
+    ) || null
+  );
+};
+
+const findAllCustomerTimelinesByFilter = async (
+  filter = {},
+  bodyFilter = {}
+) => {
+  const all = await CustomerTimeline.find(filter).lean().exec();
+  return all.filter((item) =>
+    Object.entries(bodyFilter).every(
+      ([key, value]) => item.body?.[key] === value
+    )
+  );
+};
+
+const updateCustomerTimeline = async (id, data) => {
+  return await CustomerTimeline.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+};
+const updateManyCustomerTimelinesByFilter = async (filter = {}, data = {}) => {
+  await CustomerTimeline.updateMany(filter, data).exec();
+  const updatedDocs = await CustomerTimeline.find(filter).lean().exec();
+  return updatedDocs;
+};
+
+const updateCustomerTimelineByFilter = async (filter, data) => {
+  return await CustomerTimeline.findOneAndUpdate(filter, data, {
+    new: true,
+  }).exec();
+};
+
+const deleteCustomerTimeline = async (id) => {
+  return await CustomerTimeline.findByIdAndDelete(id).exec();
+};
+
+const deleteAllCustomerTimelinesByWorkspace = async (workspaceId) => {
+  return await CustomerTimeline.deleteMany({ workspaceId }).exec();
+};
+
+module.exports = {
+  createCustomerTimeline,
+  findCustomerTimelinesByWorkspaceId,
+  findCustomerTimelinesByWorkspace,
+  findCustomerTimelineByFilter,
+  updateCustomerTimeline,
+  updateCustomerTimelineByFilter,
+  deleteCustomerTimeline,
+  deleteAllCustomerTimelinesByWorkspace,
+  findAllCustomerTimelinesByFilter,
+  updateManyCustomerTimelinesByFilter,
+};

package/common/repositories/descriptionTemplates.repository.js

@@ -0,0 +1,229 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+// const DescriptionTemplate = require("../../../models/DescriptionTemplate");
+const DescriptionTemplate = require("../../models/DescriptionTemplate");
+
+const CACHE_KEY_ALL = "description_templates_all";
+
+/**
+ * Get cached descriptionTemplates for all workspaces.
+ */
+const getCachedAllDescriptionTemplates = async () => {
+  let descriptionTemplates = await getRedisData(CACHE_KEY_ALL);
+  if (!descriptionTemplates) {
+    descriptionTemplates = await DescriptionTemplate.find({}).lean().exec();
+    await setRedisData(CACHE_KEY_ALL, descriptionTemplates);
+  }
+  return descriptionTemplates;
+};
+
+/**
+ * Update cached descriptionTemplates for all workspaces.
+ */
+const updateCachedAllDescriptionTemplates = async () => {
+  const descriptionTemplates = await DescriptionTemplate.find({}).lean().exec();
+  await setRedisData(CACHE_KEY_ALL, descriptionTemplates);
+};
+
+/**
+ * Get cached descriptionTemplates for a specific workspace.
+ * Now uses the all descriptionTemplates cache and filters by workspaceId.
+ */
+
+/**
+ * Create a new DescriptionTemplate and update cache.
+ */
+const createTemplate = async (data) => {
+  const newTemplate = new DescriptionTemplate(data);
+  const saveDescriptionTemplate = await newTemplate.save();
+
+  // Update only the main cache
+  await updateCachedAllDescriptionTemplates();
+
+  return saveDescriptionTemplate;
+};
+
+/**
+ * Find an DescriptionTemplate by ID.
+ */
+const findTemplatesByWorkspaceId = async (workspaceId) => {
+  const allDescriptionTemplates = await getCachedAllDescriptionTemplates();
+  return allDescriptionTemplates.filter(
+    (desc) => desc.workspaceId === workspaceId
+  );
+};
+
+/**
+ * Find DescriptionTemplate by filter (supports both workspace & non-workspace).
+ */
+const findTemplateByFilter = async (
+  filter,
+  bodyFilter = {},
+  workspaceId = null
+) => {
+  const allTemplates = await getCachedAllDescriptionTemplates();
+
+  // Filter by workspaceId if provided
+  let filteredTemplates = workspaceId
+    ? allTemplates.filter((desc) => desc.workspaceId === workspaceId)
+    : allTemplates;
+
+  return (
+    filteredTemplates.find(
+      (item) =>
+        // Check direct properties of item
+        Object.entries(filter).every(([key, value]) => item[key] === value) &&
+        // If bodyFilter is provided, check inside item.body
+        Object.entries(bodyFilter).every(
+          ([key, value]) => item.body?.[key] === value
+        )
+    ) || null
+  );
+};
+const findAllTemplateByFilter = async (
+  filter,
+  bodyFilter = {},
+  workspaceId = null
+) => {
+  const allTemplates = await getCachedAllDescriptionTemplates();
+
+  // Filter by workspaceId if provided
+  let filteredTemplates = workspaceId
+    ? allTemplates.filter((desc) => desc.workspaceId === workspaceId)
+    : allTemplates;
+
+  return (
+    filteredTemplates.filter(
+      (item) =>
+        // Check direct properties of item
+        Object.entries(filter).every(([key, value]) => item[key] === value) &&
+        // If bodyFilter is provided, check inside item.body
+        Object.entries(bodyFilter).every(
+          ([key, value]) => item.body?.[key] === value
+        )
+    ) || null
+  );
+};
+const createOrUpdateTemplate = async (filter, data) => {
+  const template = await DescriptionTemplate.findOneAndUpdate(filter, data, {
+    upsert: true,
+    new: true,
+  });
+  if (template) {
+    // Update only the main cache
+    await updateCachedAllDescriptionTemplates();
+  }
+  return template;
+};
+const updateTemplateById = async (id, data) => {
+  const updatedTemplate = await DescriptionTemplate.findByIdAndUpdate(
+    id,
+    data,
+    {
+      new: true,
+    }
+  ).exec();
+
+  if (updatedTemplate) {
+    // Update only the main cache
+    await updateCachedAllDescriptionTemplates();
+  }
+
+  return updatedTemplate;
+};
+
+/**
+ * Update an DescriptionTemplate by filter.
+ */
+const updateTemplateByFilter = async (filter, data, workspaceId = null) => {
+  // Add workspace filter if provided
+  const queryFilter = workspaceId ? { ...filter, workspaceId } : filter;
+
+  const updatedTemplate = await DescriptionTemplate.findOneAndUpdate(
+    queryFilter,
+    data,
+    {
+      new: true,
+    }
+  ).exec();
+
+  if (updatedTemplate) {
+    // Update only the main cache
+    await updateCachedAllDescriptionTemplates();
+  }
+
+  return updatedTemplate;
+};
+const updateManyTemplates = async (filter, data) => {
+  const queryFilter = workspaceId ? { ...filter, workspaceId } : filter;
+
+  const updatedTemplate = await DescriptionTemplate.updateMany(
+    queryFilter,
+    { $set: { ...data } },
+    {
+      new: true,
+    }
+  ).exec();
+
+  if (updatedTemplate) {
+    // Update only the main cache
+    await updateCachedAllDescriptionTemplates();
+  }
+
+  return updatedTemplate;
+};
+/**
+ * Delete an DescriptionTemplate by ID.
+ */
+const deleteTemplate = async (id) => {
+  const deletedTemplate = await DescriptionTemplate.findByIdAndDelete(
+    id
+  ).exec();
+
+  if (deletedTemplate) {
+    await updateCachedAllDescriptionTemplates();
+  }
+
+  return deletedTemplate;
+};
+
+const deleteAllTemplatesByWorkspace = async (workspaceId) => {
+  await DescriptionTemplate.deleteMany({ workspaceId }).exec();
+
+  await updateCachedAllDescriptionTemplates();
+};
+
+const findTemplateById = async (id) => {
+  return await DescriptionTemplate.findById(id).lean().exec();
+};
+
+const deleteTemplatesByFilter = async (filter) => {
+  await DescriptionTemplate.deleteMany(filter).exec();
+
+  await updateCachedAllDescriptionTemplates();
+};
+
+const insertManyTemplates = async (templates) => {
+  const insertedTemplates = await DescriptionTemplate.insertMany(templates);
+
+  if (insertedTemplates?.length > 0) {
+    await updateCachedAllDescriptionTemplates();
+  }
+
+  return insertedTemplates;
+};
+
+module.exports = {
+  createTemplate,
+  createOrUpdateTemplate,
+  findTemplateByFilter,
+  findTemplatesByWorkspaceId,
+  updateTemplateById,
+  updateTemplateByFilter,
+  updateManyTemplates,
+  deleteTemplate,
+  deleteAllTemplatesByWorkspace,
+  findTemplateById,
+  deleteTemplatesByFilter,
+  insertManyTemplates,
+  findAllTemplateByFilter,
+};

package/common/repositories/index.js

@@ -0,0 +1,34 @@
+const workspaceRepository = require("./workspace.repository");
+const integrationRepository = require("./integration.repository");
+const descriptionTemplateRepository = require("./descriptionTemplates.repository");
+const shipperRepository = require("./shipper.repository");
+const labelRepository = require("./label.repository");
+const userRepository = require("./user.repository");
+const userRoleRepository = require("./userRole.repository");
+const settingRepository = require("./settings.repository");
+const socialMediaSettingRepository = require("./socialMediaSetting.repository");
+const chatMemberRepository = require("./chatMember.repository");
+const roleRepository = require("./role.repository");
+const userPermissionRepository = require("./userPermission.repository");
+const userRolePermissionRepository = require("./userRolePermission.repository");
+const notificationSettingsRepository = require("./notificationSettings.repository");
+const customerProfileRepository = require("./customerProfile.repository");
+const customerTimelineRepository = require("./customerTimeline.repository");
+exports.module = {
+  workspaceRepository,
+  integrationRepository,
+  descriptionTemplateRepository,
+  shipperRepository,
+  labelRepository,
+  userRepository,
+  userRoleRepository,
+  settingRepository,
+  socialMediaSettingRepository,
+  notificationSettingsRepository,
+  chatMemberRepository,
+  roleRepository,
+  userPermissionRepository,
+  userRolePermissionRepository,
+  customerProfileRepository,
+  customerTimelineRepository,
+};

package/common/repositories/integration.repository.js

@@ -0,0 +1,210 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+const Integration = require("../../models/Integration");
+
+const CACHE_KEY_ALL = "integrations_all";
+
+/**
+ * Get cached integrations for all workspaces.
+ */
+const getCachedAllIntegrations = async () => {
+  let integrations = await getRedisData(CACHE_KEY_ALL);
+  if (!integrations) {
+    integrations = await Integration.find({}).lean().exec();
+    await setRedisData(CACHE_KEY_ALL, integrations);
+  }
+  return integrations?.map((x) => {
+    return {
+      ...x,
+      _id: x?._id?.toString(),
+    };
+  });
+};
+
+/**
+ * Update cached integrations for all workspaces.
+ */
+const updateCachedAllIntegrations = async () => {
+  const integrations = await Integration.find({}).lean().exec();
+  await setRedisData(CACHE_KEY_ALL, integrations);
+};
+
+/**
+ * Get cached integrations for a specific workspace.
+ * Now uses the all integrations cache and filters by workspaceId.
+ */
+const getCachedIntegrations = async (workspaceId) => {
+  const allIntegrations = await getCachedAllIntegrations();
+  return allIntegrations.filter((intg) => intg.workspaceId === workspaceId);
+};
+
+/**
+ * Create a new integration and update cache.
+ */
+const createIntegration = async (data) => {
+  const newIntegration = new Integration(data);
+  const savedIntegration = await newIntegration.save();
+
+  // Update only the main cache
+  await updateCachedAllIntegrations();
+
+  return savedIntegration;
+};
+
+/**
+ * Find an integration by ID.
+ */
+const findIntegrationsByWorkspaceId = async (workspaceId) => {
+  return await getCachedIntegrations(workspaceId);
+};
+
+/**
+ * Find integrations by workspace.
+ */
+const findIntegrationsByWorkspace = async (workspaceId, filter = {}) => {
+  const allIntegrations = await getCachedIntegrations(workspaceId);
+
+  return allIntegrations.filter(
+    (intg) =>
+      intg.workspaceId === workspaceId &&
+      Object.entries(filter).every(([key, value]) => intg[key] === value)
+  );
+};
+
+/**
+ * Find integration by filter (supports both workspace & non-workspace).
+ */
+const findIntegrationByFilter = async (
+  filter,
+  bodyFilter = {},
+  workspaceId = null
+) => {
+  const allIntegrations = await getCachedAllIntegrations();
+
+  let filteredIntegrations = allIntegrations;
+  if (workspaceId) {
+    filteredIntegrations = allIntegrations.filter(
+      (intg) => intg.workspaceId === workspaceId
+    );
+  }
+
+  return (
+    filteredIntegrations.find(
+      (item) =>
+        Object.entries(filter).every(([key, value]) => item[key] === value) &&
+        Object.entries(bodyFilter).every(
+          ([key, value]) => item.body?.[key] === value
+        )
+    ) || null
+  );
+};
+const findAllIntegrationByFilter = async (
+  filter = {},
+  bodyFilter = {},
+  workspaceId = null
+) => {
+  const allIntegrations = await getCachedAllIntegrations();
+
+  let filteredIntegrations = allIntegrations;
+  if (workspaceId) {
+    filteredIntegrations = allIntegrations.filter(
+      (intg) => intg.workspaceId === workspaceId
+    );
+  }
+  return (
+    filteredIntegrations.filter(
+      (item) =>
+        Object.entries(filter).every(([key, value]) => item[key] === value) &&
+        Object.entries(bodyFilter).every(
+          ([key, value]) => item.body?.[key] === value
+        )
+    ) || []
+  );
+};
+const bulkCreateAndUpdateIntegrations = async (operations) => {
+  await Integration.bulkWrite(operations);
+  await updateCachedAllIntegrations();
+  return operations;
+};
+/**
+ * Find all integrations (without workspace filtering).
+ */
+const findAllIntegrations = async () => {
+  return await getCachedAllIntegrations();
+};
+
+/**
+ * Update an integration by ID.
+ */
+const updateIntegration = async (id, data) => {
+  const updatedIntegration = await Integration.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+
+  if (updatedIntegration) {
+    // Update only the main cache
+    await updateCachedAllIntegrations();
+  }
+
+  return updatedIntegration;
+};
+
+/**
+ * Update an integration by filter.
+ */
+const updateIntegrationByFilter = async (filter, data, workspaceId = null) => {
+  // Add workspace filter if provided
+  const queryFilter = workspaceId ? { ...filter, workspaceId } : filter;
+
+  const updatedIntegration = await Integration.findOneAndUpdate(
+    queryFilter,
+    data,
+    {
+      new: true,
+    }
+  ).exec();
+
+  if (updatedIntegration) {
+    // Update only the main cache
+    await updateCachedAllIntegrations();
+  }
+
+  return updatedIntegration;
+};
+
+/**
+ * Delete an integration by ID.
+ */
+const deleteIntegration = async (id) => {
+  const deletedIntegration = await Integration.findByIdAndDelete(id).exec();
+
+  if (deletedIntegration) {
+    // Update only the main cache
+    await updateCachedAllIntegrations();
+  }
+
+  return deletedIntegration;
+};
+
+/**
+ * Delete all integrations for a specific workspace.
+ */
+const deleteAllIntegrationsByWorkspace = async (workspaceId) => {
+  await Integration.deleteMany({ workspaceId }).exec();
+
+  // Update only the main cache
+  await updateCachedAllIntegrations();
+};
+
+module.exports = {
+  createIntegration,
+  findIntegrationsByWorkspaceId,
+  findIntegrationsByWorkspace,
+  findIntegrationByFilter,
+  findAllIntegrations,
+  updateIntegration,
+  updateIntegrationByFilter,
+  deleteIntegration,
+  deleteAllIntegrationsByWorkspace,
+  findAllIntegrationByFilter,
+  bulkCreateAndUpdateIntegrations,
+};