shuttlepro-shared 1.3.13 → 1.3.14

package/models/NewProduct.js

@@ -1,71 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const NewProductSchema = new Schema(
-  {
-    id: {
-      type: Schema.Types.ObjectId,
-      ref: "Product",
-      default: null,
-    },
-    name: { type: String, default: "" },
-    description: { type: String, default: "" },
-    sku: { type: String, default: "" },
-    price: { type: String, default: 0 },
-    quantity: { type: Number, default: 0 },
-    imageUrl: { type: String, default: "" },
-    costPrice: { type: String, default: 0 },
-    salePrice: { type: String, default: 0 },
-    webProductId: { type: Number, default: null },
-    variants: [],
-    attachments: [],
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-  },
-  {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true },
-  }
-);
-
-// Adding compound text index for name, sku, and variants
-NewProductSchema.index({
-  name: "text",
-  sku: "text",
-  "variants.name": "text",
-  "variants.sku": "text",
-});
-
-// Adding separate indexes for frequent query conditions
-NewProductSchema.index({
-  workspaceId: 1,
-  name: 1,
-});
-
-NewProductSchema.index({
-  workspaceId: 1,
-  sku: 1,
-});
-
-NewProductSchema.index({
-  workspaceId: 1,
-  "variants.name": 1,
-});
-
-NewProductSchema.index({
-  workspaceId: 1,
-  "variants.sku": 1,
-});
-
-// Index for attachments existence check
-NewProductSchema.index({
-  attachments: 1,
-});
-
-const NewProduct = mongoose.model("NewProduct", NewProductSchema);
-
-module.exports = NewProduct;

package/models/NotificationSettings.js

@@ -1,130 +0,0 @@
-const { model, Schema } = require("mongoose");
-
-const NotificationSettingsSchema = new Schema(
-  {
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-
-    orders: {
-      type: {
-        createOrder: {
-          type: Boolean,
-          default: false,
-        },
-        orderAssign: {
-          type: Boolean,
-          default: false,
-        },
-        orderComment: {
-          type: Boolean,
-          default: false,
-        },
-      },
-      default: {
-        createOrder: false,
-        orderAssign: false,
-        orderComment: false,
-      },
-    },
-
-    products: {
-      type: Boolean,
-      default: false,
-    },
-
-    socialProfiles: {
-      type: {
-        socialProfileComment: {
-          type: Boolean,
-          default: false,
-        },
-        story: {
-          type: Boolean,
-          default: false,
-        },
-      },
-      default: {
-        socialProfileComment: false,
-        story: false,
-      },
-    },
-
-    conversation: {
-      type: {
-        instaMessage: {
-          type: Boolean,
-          default: false,
-        },
-        fbMessage: {
-          type: Boolean,
-          default: false,
-        },
-        whatsapp: {
-          type: Boolean,
-          default: false,
-        },
-        instaComment: {
-          type: Boolean,
-          default: false,
-        },
-        fbComment: {
-          type: Boolean,
-          default: false,
-        },
-        email: {
-          type: Boolean,
-          default: false,
-        },
-      },
-      default: {
-        instaMessage: false,
-        fbMessage: false,
-        instaComment: false,
-        fbComment: false,
-        email: false,
-        whatsapp: false,
-      },
-    },
-
-    taskManager: {
-      type: {
-        cardAssign: {
-          type: Boolean,
-          default: false,
-        },
-        cardMove: {
-          type: Boolean,
-          default: false,
-        },
-      },
-      default: {
-        cardAssign: false,
-        cardMove: false,
-      },
-    },
-
-    sound: {
-      type: {
-        play: {
-          type: Boolean,
-          default: true,
-        },
-      },
-      default: {
-        play: true,
-      },
-    },
-
-    default: {
-      type: Boolean,
-      default: true,
-    },
-    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = model("NotificationSettings", NotificationSettingsSchema);

package/models/Order.js

@@ -1,236 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-const normalizePhoneNumber = (phone) => {
-  let normalized = phone.replace(/[^\d]/g, "");
-  if (normalized.startsWith("92")) {
-    normalized = normalized.replace(/^92/, "");
-  }
-  if (normalized.startsWith("0")) {
-    normalized = normalized.substring(1);
-  }
-  return normalized;
-};
-const getPhoneRegex = (phone) => {
-  const normalizedPhone = normalizePhoneNumber(phone);
-  return new RegExp(
-    `^0?${normalizedPhone}$|^\\+92${normalizedPhone}$|^${normalizedPhone}$`,
-    "i"
-  );
-};
-const _ = require("lodash");
-
-const ShipperInformation = new Schema({
-  _id: false,
-  shipperType: { type: String, default: "" },
-  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: 1 }, //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
-  remarks: { type: String, default: "" },
-  customer_note: { type: String, default: "" },
-  orderId: { type: Schema.Types.ObjectId, ref: "Order", default: null },
-  return_branch: { type: String, default: "" },
-  cityData: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
-  //TRAX
-  paymentMode: { type: Number, default: 0 },
-  addressId: { type: Number, default: 0 },
-  itemProductType: { type: Number, default: 0 },
-  shippingMode: { type: Number, default: 0 },
-  itemInsurance: { type: Boolean, default: false },
-  informationDisplay: { type: String, default: "" },
-  //Call Courier (CC)
-  shipperName: { type: String, default: "" },
-  shipperEmail: { type: String, default: "" },
-  shipperCellNo: { type: String, default: "" },
-  shipperLandlineNo: { type: String, default: "" },
-  shipperAddress: { type: String, default: "" },
-  shipperCityId: { type: Number, default: 0 },
-  shipperAreaId: { type: Number, default: 0 },
-});
-
-const OrderSchema = new Schema(
-  {
-    webOrderId: { type: String, default: "" },
-    webOrderNumber: { type: String, default: "" },
-    orderNumber: { type: String, default: "" },
-    customerId: { type: Schema.Types.ObjectId, ref: "Customer", default: null },
-    customerName: { type: String, default: "" },
-    customerPhone: { type: String, default: "" },
-    customerAddress: { type: String, default: "" },
-    cityName: { type: String, default: "" },
-    trackingId: { type: String, default: "" },
-    shipperInformation: ShipperInformation,
-    isCnGenerated: { type: Boolean, default: false },
-    swap: { type: String, default: "" },
-    status: { type: String, default: "" },
-    lastStatusTime: { type: String, default: "" },
-    statusType: { type: String, default: "" },
-    returnOrder: {
-      received: { type: Boolean, default: false },
-      restocked: { type: Boolean, default: false },
-      remarks: { type: String, default: "" },
-    },
-    statusTypeId: {
-      type: Schema.Types.ObjectId,
-      ref: "StatusType",
-      default: null,
-    },
-    statusId: {
-      type: Schema.Types.ObjectId,
-      ref: "Status",
-      default: null,
-    },
-    totalAmount: { type: Number, default: 0 },
-    payableAmount: { type: Number, default: 0 },
-    parcelValue: { type: Number, default: 0 },
-    payableAmount: { type: Number, default: 0 },
-    discountPercentage: { type: Number, default: 0 },
-    discountValue: { type: Number, default: 0 },
-    productDetails: { type: String, default: "" },
-    webOrderId: { type: String, default: "" },
-    parentOrderId: { type: Schema.Types.ObjectId, ref: "Order", default: null },
-    webOrderNumber: { type: String, default: "" },
-    fulfillmentStatus: { type: String, default: "" },
-    webFulfillmentId: { type: String, default: "" },
-    platformFinancialStatus: { type: String, default: "pending" },
-    pinLocation: { type: String, default: "" },
-    deliveryCharges: { type: Number, default: 0 },
-    tax: { type: Number, default: 0 },
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-    orderType: { type: String, default: "" },
-    barCode: { type: String, default: "" },
-    quantity: { type: Number, default: 0 },
-    assignTo: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    isLoadSheetGenerated: { type: Boolean, default: false },
-    orderDate: { type: String, default: "" },
-    returnDate: { type: String, default: "" },
-    receivedDate: { type: String, default: "" },
-    published: { type: Boolean, default: false },
-    isFlagged: { type: Boolean, default: false },
-    publishedTime: { type: String, default: "" },
-    paymentType: { type: String, default: "COD" },
-    isDeleted: { type: Boolean, default: false },
-    isFake: { type: Boolean, default: false },
-    statusUpdatedAt: { type: String, default: "" },
-    invalidCity: { type: Boolean, default: false },
-    invalidCredentials: { type: Boolean, default: false },
-    isConfirmed: { type: Boolean, default: false },
-    confirmedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    priority: { type: String, default: "" },
-    isBulk: { type: String, default: "" },
-    conversationId: { type: String, default: "" },
-    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    publishedStatus: { type: String, default: "pending" },
-    isDuplicate: { type: Boolean, default: false },
-    ivrGenerated: { type: Boolean, default: false },
-    isActivityGenerated: { type: Boolean, default: false },
-    payment: {
-      isPaid: { type: Boolean, default: false },
-      paymentDate: { type: String, default: "" },
-      paymentDetails: {},
-    },
-    credentials: {},
-    ticketId: { type: String, default: "" },
-    sender: { type: String, default: "" },
-    orderName: { type: String, default: "" },
-    totalWeight: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-OrderSchema.virtual("checkPoints", {
-  ref: "Checkpoint",
-  localField: "_id",
-  foreignField: "orderId",
-});
-
-OrderSchema.virtual("orderProducts", {
-  ref: "OrderProduct",
-  localField: "_id",
-  foreignField: "orderId",
-});
-
-OrderSchema.post("save", async function (doc) {
-  try {
-    if (doc) {
-      markOrUnMarkOrderAsDuplicate(doc);
-    }
-    return { code: 200 };
-  } catch (err) {
-    console.log("err", err);
-    return { code: 400 };
-  }
-});
-
-OrderSchema.post("findOneAndUpdate", async function (doc) {
-  try {
-    if (doc) {
-      markOrUnMarkOrderAsDuplicate(doc);
-    }
-    return { code: 200 };
-  } catch (err) {
-    console.log("err", err);
-    return { code: 400 };
-  }
-});
-
-const markOrUnMarkOrderAsDuplicate = async (doc) => {
-  try {
-    if (["pending", "cancelled", "published"].includes(doc?.statusType)) {
-      if (["cancelled"].includes(doc?.statusType)) {
-        await Order.updateOne(
-          { _id: doc?._id },
-          { $set: { isDuplicate: false } }
-        );
-      }
-      const phoneRegex = getPhoneRegex(doc?.customerPhone);
-      let orders = await Order.find({
-        workspaceId: doc?.workspaceId,
-        isDeleted: false,
-        statusType: "pending",
-        customerPhone: phoneRegex,
-      })
-        .lean()
-        .exec();
-      if (orders?.length > 1) {
-        const ordersByCity = _.groupBy(orders, "cityName");
-        const bulkOps = [];
-        for (const cityName in ordersByCity) {
-          const cityOrders = ordersByCity[cityName];
-          const isDuplicate = cityOrders.length > 1;
-          const orderIds = cityOrders.map((order) => order?._id);
-          bulkOps.push({
-            updateMany: {
-              filter: { _id: { $in: orderIds } },
-              update: { $set: { isDuplicate } },
-            },
-          });
-        }
-        if (bulkOps.length > 0) {
-          await Order.bulkWrite(bulkOps);
-        }
-      } else {
-        await Order.updateMany(
-          { _id: { $in: orders.map((d) => d?._id?.toString()) } },
-          { $set: { isDuplicate: false } }
-        );
-      }
-      return { code: 200 };
-    }
-    return { code: 200 };
-  } catch (err) {
-    console.log("err", err);
-    return { code: 400 };
-  }
-};
-
-const Order = mongoose.model("Order", OrderSchema);
-
-module.exports = Order;

package/models/OrderProduct.js

@@ -1,37 +0,0 @@
-const { Schema, model } = require("mongoose");
-const OrderProductSchema = new Schema(
-  {
-    orderId: { type: Schema.Types.ObjectId, ref: "Order", default: null },
-    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
-    variantId: {
-      type: Schema.Types.ObjectId,
-      ref: "ProductVariant",
-      default: null,
-    },
-    locationId: {
-      type: Schema.Types.ObjectId,
-      ref: "Location",
-      default: null,
-    },
-    quantity: { type: Number, default: 0 },
-    price: { type: Number, default: 0 },
-    totalAmount: { type: Number, default: 0 },
-    discountPercentage: { type: Number, default: 0 },
-    webFulfillmentOrderId: { type: String, default: "" },
-    webFulfillmentId: { type: String, default: "" },
-    isFullfilled: { type: Boolean, default: false },
-    isDeleted: { type: Boolean, default: false },
-    discountValue: { type: Number, default: 0 },
-    webLineItemId: { type: String, default: "" },
-    status: { type: String, default: "open" },
-    hyperLink: { type: String, default: "" },
-    parentOrderProductId: { type: Schema.Types.ObjectId, default: null },
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-module.exports = model("OrderProduct", OrderProductSchema);

package/models/Profile.js

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

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

@@ -1,18 +0,0 @@
-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);