shuttlepro-shared 1.1.96 → 1.1.98

package/common/repositories/descriptionTemplates.repository.js

@@ -0,0 +1,186 @@
+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 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) {
+    // Update only the main cache
+    await updateCachedAllDescriptionTemplates();
+  }
+
+  return deletedTemplate;
+};
+
+/**
+ * Delete all descriptionTemplates for a specific workspace.
+ */
+const deleteAllTemplatesByWorkspace = async (workspaceId) => {
+  await DescriptionTemplate.deleteMany({ workspaceId }).exec();
+
+  // Update only the main cache
+  await updateCachedAllDescriptionTemplates();
+};
+
+module.exports = {
+  createTemplate,
+  createOrUpdateTemplate,
+  findTemplateByFilter,
+  findTemplatesByWorkspaceId,
+  updateTemplateById,
+  updateTemplateByFilter,
+  updateManyTemplates,
+  deleteTemplate,
+  deleteAllTemplatesByWorkspace,
+};

package/common/repositories/index.js

@@ -0,0 +1,12 @@
+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");
+exports.module = {
+  workspaceRepository,
+  integrationRepository,
+  descriptionTemplateRepository,
+  shipperRepository,
+  labelRepository,
+};

package/common/repositories/integration.repository.js

@@ -0,0 +1,197 @@
+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;
+};
+
+/**
+ * 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, 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.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,
+};

package/common/repositories/label.repository.js

@@ -0,0 +1,85 @@
+const { getRedisData, setRedisData } = require("../../config/redis");
+const Label = require("../../models/Label");
+
+const CACHE_KEY_ALL = "labels_all";
+
+const getCachedLabels = async () => {
+  let labels = await getRedisData(CACHE_KEY_ALL);
+  if (!labels) {
+    labels = await Label.find().lean().exec();
+    await setRedisData(CACHE_KEY_ALL, JSON.stringify(labels));
+  } else {
+    labels = JSON.parse(labels);
+  }
+  return labels;
+};
+
+const updateCachedLabels = async () => {
+  const labels = await Label.find().lean().exec();
+  await setRedisData(CACHE_KEY_ALL, JSON.stringify(labels));
+};
+
+const createLabel = async (data) => {
+  const newLabel = new Label(data);
+  const savedLabel = await newLabel.save();
+  await updateCachedLabels();
+  return savedLabel;
+};
+
+const findLabelById = async (id) => {
+  const labels = await getCachedLabels();
+  return labels.find((l) => l._id.toString() === id) || null;
+};
+
+const findLabel = async (filter) => {
+  const labels = await getCachedLabels();
+  return (
+    labels.find((l) =>
+      Object.entries(filter).every(([key, value]) => l[key] === value)
+    ) || null
+  );
+};
+
+const findAllLabels = async (filter = {}) => {
+  const labels = await getCachedLabels();
+  return labels.filter((l) =>
+    Object.entries(filter).every(([key, value]) => l[key] === value)
+  );
+};
+
+const updateLabelById = async (id, data) => {
+  const updatedLabel = await Label.findByIdAndUpdate(id, data, {
+    new: true,
+  }).exec();
+  if (updatedLabel) {
+    await updateCachedLabels();
+  }
+  return updatedLabel;
+};
+const updateLabel = async (filter, data) => {
+  const updatedLabel = await Label.findOneAndUpdate(filter, data, {
+    new: true,
+  }).exec();
+  if (updatedLabel) {
+    await updateCachedLabels();
+  }
+  return updatedLabel;
+};
+
+const deleteLabel = async (id) => {
+  const deletedLabel = await Label.findByIdAndDelete(id).exec();
+  if (deletedLabel) {
+    await updateCachedLabels();
+  }
+  return deletedLabel;
+};
+
+module.exports = {
+  createLabel,
+  findLabelById,
+  findLabel,
+  findAllLabels,
+  updateLabel,
+  deleteLabel,
+  updateLabelById,
+};

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/workspace.repository.js

@@ -0,0 +1,95 @@
+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().exec();
+    await setRedisData(CACHE_KEY_ALL, JSON.stringify(workspaces));
+  } else {
+    workspaces = JSON.parse(workspaces);
+  }
+  return workspaces;
+};
+
+const updateCachedWorkspaces = async () => {
+  const workspaces = await Workspace.find().exec();
+  await setRedisData(CACHE_KEY_ALL, JSON.stringify(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) || 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 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 updateWorkspace = async (id, data) => {
+  const updatedWorkspace = await Workspace.findByIdAndUpdate(id, data, {
+    new: true,
+  }).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,
+  findWorkspaceById,
+  findWorkspace,
+  findWorkspaceByIdAndQueueTracking,
+  findAllWorkspaces,
+  updateWorkspace,
+  deleteWorkspace,
+};