shuttlepro-shared 1.3.14 → 1.3.16

package/models/Profile.js

@@ -0,0 +1,127 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const { setRedisData, getRedisData } = require("../config/redis");
+
+const ProfileSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    userName: { type: String, default: "" },
+    profilePicture: { type: String, default: "" },
+    profileId: { type: String, default: "" },
+    isSpam: { type: Boolean, default: false },
+    workspaceId: { type: String, default: "" },
+    email: { type: String, default: "" },
+    phoneNo: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+const Profile = mongoose.model("Profile", ProfileSchema);
+
+const addOrUpdateProfilesInRedis = async (profile) => {
+  try {
+    const docId = profile?._id.toString();
+    let profiles = await fetchProfiles(profile?.workspaceId);
+    const profilesMap = profiles.reduce((map, p) => {
+      map[p._id.toString()] = p;
+      return map;
+    }, {});
+    profilesMap[docId] = profile.toObject();
+    profiles = Object.values(profilesMap);
+    setRedisData(`${profile?.workspaceId}-profiles`, profiles);
+    return { code: 200 };
+  } catch (err) {
+    return { code: 400 };
+  }
+};
+
+const fetchProfiles = async (workspaceId) => {
+  try {
+    let profiles = await getRedisData(`${workspaceId}-profiles`);
+    if (!profiles || profiles.length === 0) {
+      profiles = await Profile.find({ workspaceId }).lean().exec();
+      setRedisData(`${workspaceId}-profiles`, profiles);
+    }
+    return profiles;
+  } catch (err) {
+    return [];
+  }
+};
+
+const fetchByProfileIdAndWorkspaceId = async (id, workspaceId) => {
+  try {
+    let profiles = await fetchProfiles(workspaceId);
+    let profile = profiles.find(
+      (p) =>
+        (p?.profileId === id || p._id.toString() === id.toString()) &&
+        p?.workspaceId.toString() === workspaceId.toString()
+    );
+    return profile || null;
+  } catch (err) {
+    return null;
+  }
+};
+
+const fetchProfileByEmailAndWorkspaceId = async (
+  workspaceId,
+  userName = ""
+) => {
+  try {
+    let profiles = await fetchProfiles(workspaceId);
+    let profile = profiles.find(
+      (p) => p?.userName === userName && p?.workspaceId === workspaceId
+    );
+    return profile || null;
+  } catch (err) {
+    console.log(err, "err");
+    return null;
+  }
+};
+
+const createProfile = async (obj) => {
+  try {
+    let profile = await Profile.create(obj);
+    await addOrUpdateProfilesInRedis(profile);
+    return profile;
+  } catch (err) {
+    console.log(err, "err");
+    return null;
+  }
+};
+const createUpdateProfileModified = async (filter, obj) => {
+  try {
+    let profile = await Profile.findOneAndUpdate(
+      filter,
+      { ...obj, ...filter },
+      {
+        new: true,
+        upsert: true,
+      }
+    );
+    await addOrUpdateProfilesInRedis(profile);
+    return profile;
+  } catch (err) {
+    console.log(err, "err");
+    return null;
+  }
+};
+const updateProfile = async (query, payload) => {
+  try {
+    const profile = await Profile.findOneAndUpdate(query, payload, {
+      new: true,
+    });
+    await addOrUpdateProfilesInRedis(profile);
+    return profile;
+  } catch (err) {
+    return null;
+  }
+};
+
+module.exports = {
+  fetchByProfileIdAndWorkspaceId,
+  fetchProfileByEmailAndWorkspaceId,
+  createProfile,
+  updateProfile,
+  fetchProfiles,
+  Profile,
+  createUpdateProfileModified,
+};

package/models/Report.js

@@ -0,0 +1,27 @@
+const mongoose = require("mongoose");
+
+const reportSchema = new mongoose.Schema(
+  {
+    workspaceId: { type: String, default: "" },
+    type: {
+      type: String,
+      default: "",
+    },
+    title: { type: String, default: "" },
+    mode: { type: String, default: "combined" },
+    displayType: { type: String, default: "table" },
+    filter: {},
+    dateRange: {
+      startDate: { type: String, default: "" },
+      endDate: { type: String, default: "" },
+    },
+    actions: [],
+    processedData: [],
+  },
+  { timestamps: true }
+);
+
+reportSchema.index({ type: 1, workspaceId: 1 });
+reportSchema.index({ type: 1, workspaceId: 1, title: 1 });
+
+module.exports = mongoose.model("Report", reportSchema);

package/models/Setting.js

@@ -0,0 +1,18 @@
+const { model, Schema } = require("mongoose");
+
+const SettingSchema = new Schema(
+  {
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    settings: [{ module: { type: String, default: "" }, options: {} }],
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updateBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("Setting", SettingSchema);

package/models/Shipper.js

@@ -0,0 +1,62 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const shipperInformationSchema = new Schema({
+  weight: { type: Number, default: 0 }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  fragile: { type: Boolean, default: false }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  serviceType: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  serviceTypeId: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  pieces: { type: Number, default: 0 }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  originCityName: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  costCenterCode: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  remarks: { type: String, default: "" },
+  customer_note: { type: String, default: "" },
+  cityData: { type: String, default: "" },
+  return_branch: { type: String, default: "" },
+  //M&P, TRAX, INSTA, RIDER, TCS, CC
+  //TRAX
+  paymentMode: { type: Number, default: 0 },
+  addressId: { type: Number, default: 0 }, //this will not be shown
+  itemProductType: { type: Number, default: 0 },
+  shippingMode: { type: Number, default: 0 },
+  itemInsurance: { type: Boolean, default: false }, //this will not be shown
+  informationDisplay: { type: String, default: "" },
+  //Call Courier (CC)
+  shipperId: { type: Number, default: 0 }, //this will not be showm
+  shipperName: { type: String, default: "" }, //this will not be shown
+  shipperEmail: { type: String, default: "" }, //this will not be shown
+  shipperCellNo: { type: String, default: "" }, //this will not be shown
+  shipperLandlineNo: { type: String, default: "" }, //this will not be shown
+  shipperAddress: { type: String, default: "" }, //this will not be shown
+  shipperCityId: { type: Number, default: 0 }, //this will not be shown
+  shipperAreaId: { type: Number, default: 0 }, //this will not be shown
+  locationId: { type: Number, default: 0 }, //this will not be shown
+});
+
+const shipperSchema = new mongoose.Schema(
+  {
+    type: { type: String, default: "" },
+    userName: { type: String, default: "" },
+    password: { type: String, default: "" },
+    clientId: { type: String, default: "" },
+    clientSecret: { type: String, default: "" },
+    bearerToken: { type: String, default: "" },
+    accessToken: { type: String, default: "" },
+    accountNo: { type: String, default: "" },
+    businessName: { type: String, default: "" },
+    businessPhone: { type: String, default: "" },
+    businessAddress: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    shipperInformation: shipperInformationSchema,
+    isDeleted: { type: Boolean, default: false },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("shipper", shipperSchema);

package/models/SocialMediaSetting.js

@@ -0,0 +1,28 @@
+const { Schema, model } = require("mongoose");
+const SocialMediaSettingSchema = new Schema(
+  {
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    approvers: [
+      {
+        type: Schema.Types.ObjectId,
+        ref: "User",
+        default: null,
+      },
+    ],
+    publishers: [
+      {
+        type: Schema.Types.ObjectId,
+        ref: "User",
+        default: null,
+      },
+    ],
+    defaultApprove: { type: Boolean, default: true },
+    defaultPublish: { type: Boolean, default: true },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+module.exports = model("SocialMediaSetting", SocialMediaSettingSchema);

package/models/Status.js

@@ -0,0 +1,58 @@
+const { Schema, model } = require("mongoose");
+const { setRedisData, getRedisData } = require("../config/redis");
+
+const StatusSchema = new Schema(
+  {
+    value: { type: String, default: "" },
+    description: { type: String, default: "" },
+    severity: { type: String, default: "1" },
+    shipperType: { type: String, default: "" },
+    internalValue: { type: String, default: "" },
+    statusTypeId: { type: Schema.Types.ObjectId, ref: "StatusType" },
+    type: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+StatusSchema.post("save", async function (doc) {
+  try {
+    addOrUpdateStatusInCache(doc);
+  } catch (err) {
+    console.log("err", err);
+  }
+});
+
+StatusSchema.post("findOneAndUpdate", async function (doc) {
+  try {
+    addOrUpdateStatusInCache(doc);
+  } catch (err) {
+    console.log("err", err);
+  }
+});
+
+const addOrUpdateStatusInCache = async (doc) => {
+  try {
+    const docId = doc?._id.toString();
+    let statuses = (await getRedisData("statuses")) || [];
+    if (!statuses || statuses.length === 0) {
+      // Fetch all statuses from the database if not found in Redis
+      const allStatuses = await model("Status").find().lean().exec();
+      statuses = allStatuses;
+      await setRedisData("statuses", statuses);
+    } else {
+      const statusesMap = statuses.reduce((map, status) => {
+        map[status._id.toString()] = status;
+        return map;
+      }, {});
+      statusesMap[docId] = doc.toObject();
+      statuses = Object.values(statusesMap);
+      await setRedisData("statuses", statuses);
+    }
+    return { code: 200 };
+  } catch (err) {
+    console.log("Error in addOrUpdateOrderInCache:", err);
+    return { code: 400 };
+  }
+};
+
+module.exports = model("Status", StatusSchema);

package/models/StatusType.js

@@ -0,0 +1,10 @@
+const { Schema, model } = require("mongoose");
+
+const StatusTypeSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("StatusType", StatusTypeSchema);

package/models/Step.js

@@ -0,0 +1,50 @@
+const { Schema, model } = require("mongoose");
+const StepSchema = new Schema(
+  {
+    placeholder: {
+      type: String,
+      default: "",
+    },
+    input: {
+      isRequire: {
+        type: Boolean,
+        default: false,
+      },
+      hint: {
+        type: String,
+        default: "",
+      },
+    },
+    apiCall: {
+      type: String,
+      default: "",
+    },
+    templateId: {
+      type: Schema.Types.ObjectId,
+      ref: "DescriptionTemplate",
+      default: null,
+    },
+    // module: {
+    //   type: String,
+    //   enum: ["product", "order", "customer", "general"],
+    //   default: "general",
+    // },
+    parentId: {
+      type: Schema.Types.ObjectId,
+      ref: "Step",
+      default: null,
+    },
+    sortNumber: {
+      type: Number,
+      default: 0,
+    },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    chatbotId: { type: Schema.Types.ObjectId, ref: "Chatbot", default: null },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+module.exports = model("Step", StepSchema);

package/models/Type.js

@@ -0,0 +1,25 @@
+const mongoose = require("mongoose");
+
+const typeSchema = new mongoose.Schema(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    deleted: {
+      type: Boolean,
+      default: false,
+    },
+    workspaceId: { type: String, default: "" },
+    color: { type: String, default: "#4a90e2", required: true },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+typeSchema.virtual("cardList", {
+  ref: "Card",
+  localField: "_id",
+  foreignField: "typeId",
+});
+
+module.exports = mongoose.model("Type", typeSchema);

package/models/UserRole.js

@@ -1,15 +1,6 @@
 const mongoose = require("mongoose");
 const { Schema } = mongoose;
 
-const daySchema = new Schema({
-  day: { type: String, required: true },
-  startTime: { type: String, required: false },
-  endTime: { type: String, required: false },
-  breakStartTime: { type: String, required: false },
-  breakEndTime: { type: String, required: false },
-  lateThreshold: { type: String, required: false },
-});
-
 const userRoleSchema = new Schema(
   {
     userId: {
@@ -32,10 +23,7 @@ const userRoleSchema = new Schema(
       default: null,
     },
     isOwner: { type: Boolean, default: false },
-    userShift: {
-      shiftName: { type: String, required: false },
-      days: { type: [daySchema], required: false },
-    },
+    userShift: { type: Object, default: null },
     createdBy: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",
@@ -52,112 +40,6 @@ const userRoleSchema = new Schema(
 
 const UserRole = mongoose.model("UserRole", userRoleSchema);
 
-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 getUserRoleWithPermissions = async (workspaceId, userId) => {
-  try {
-    let data = await UserRole.findOne({
-      workspaceId: workspaceId,
-      userId: userId,
-    })
-      .populate({
-        path: "roleId",
-        select:
-          "id name userId userShift permissionId modulePermissions defaultModule",
-        populate: [{ path: "permissionId", select: "id name" }],
-      })
-      .lean()
-      .exec();
-    return {
-      ...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 || "",
-    };
-  } catch (err) {
-    console.error("Error in getUserRole:", err);
-    return null;
-  }
-};
-
-const getUserPermissions = async (workspaceId, userId) => {
-  try {
-    let data = await UserRole.findOne({
-      workspaceId: workspaceId,
-      userId: userId,
-    })
-      .select("roleId userId")
-      .populate({
-        path: "roleId",
-        select: "modulePermissions",
-      })
-      .lean()
-      .exec();
-    return (
-      convertPermissionsArrayToObject(
-        data?.roleId?.modulePermissions?.modules
-      ) || null
-    );
-  } catch (err) {
-    console.error("Error in getUserRole:", err);
-    return null;
-  }
-};
-
-const getChannelsPermissions = async (workspaceId, userId) => {
-  try {
-    let data = await UserRole.findOne({
-      workspaceId: workspaceId,
-      userId: userId,
-    })
-      .select("roleId userId")
-      .populate({
-        path: "roleId",
-        select: "modulePermissions",
-      })
-      .lean()
-      .exec();
-    return (
-      convertPermissionsArrayToObject(
-        data?.roleId?.modulePermissions?.modules
-      )?.["conversations"]?.["integrationPermissions"] || []
-    );
-  } catch (err) {
-    console.error("Error in getUserRole:", err);
-    return null;
-  }
-};
-
 module.exports = {
   UserRole,
-  getChannelsPermissions,
-  getUserPermissions,
-  getUserRoleWithPermissions,
 };

package/models/UserWorkflow.js

@@ -0,0 +1,46 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const userWorkflow = new Schema(
+  {
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      default: null,
+      ref: "Workspace",
+    },
+    workflow: {},
+    receiverId: {
+      type: String,
+      default: "",
+    },
+    whatsappTemplateData: {},
+    whatsappTemplate: {},
+    targetPayload: {},
+    business: {},
+    sender: {},
+    currentRetry: {
+      type: Number,
+      default: 0,
+    },
+    currentAction: {
+      type: String,
+      default: "",
+    },
+    lastMessage: {
+      type: String,
+      default: "",
+    },
+    status: {
+      type: String,
+      default: "pending",
+    },
+    otherTypeEvent: {
+      type: Boolean,
+      default: false,
+    },
+    allActions: [],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("UserWorkflow", userWorkflow);

package/models/Website.js

@@ -29,7 +29,6 @@ const websiteSchema = new mongoose.Schema(
     },
     importStatus: { type: Boolean, default: false },
     mode: { type: String, default: "read" },
-    details: { type: mongoose.Schema.Types.Mixed, default: {} },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );