shuttlepro-shared 1.1.80 → 1.1.82

package/models/CardComments.js

@@ -1,33 +0,0 @@
-const mongoose = require("mongoose");
-
-const cardCommentSchema = new mongoose.Schema(
-  {
-    cardId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Card",
-      required: true,
-    },
-    commentText: {
-      type: String,
-      required: true,
-    },
-    createdBy: {
-      type: Object,
-      required: true,
-    },
-    readers: {
-      type: [],
-      default: [],
-    },
-    deleted: {
-      type: Boolean,
-      default: false,
-    },
-    updatedDate: {
-      type: Date,
-    },
-  },
-  { timestamps: true }
-);
-
-module.exports = mongoose.model("CardComment", cardCommentSchema);

package/models/Checkpoint.js

@@ -1,50 +0,0 @@
-const { Schema, model } = require("mongoose");
-const Order = require("./Order");
-const CheckpointSchema = new Schema(
-  {
-    bookingDate: { type: String, default: "" },
-    shipperType: { type: String, default: "" },
-    statusTime: { type: String, default: "" },
-    orderId: { type: Schema.Types.ObjectId, default: null, ref: "Order" },
-    statusId: { type: Schema.Types.ObjectId, default: null, ref: "Status" },
-    statusValue: { type: String, default: "" },
-    description: { type: String, default: "" },
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-const initialStatuses = {
-  POSTEX: "departed to postex. warehouse",
-  DAEWOO: "booking",
-  TRAX: "shipment - arrived at origin",
-};
-
-CheckpointSchema.post("save", async function (doc) {
-  try {
-    if (
-      doc?.shipperType &&
-      doc?.statusValue.toLowerCase() === initialStatuses[doc?.shipperType]
-    ) {
-      let order = await Order.findOneAndUpdate(
-        {
-          _id: doc.orderId,
-          workspaceId: doc.workspaceId,
-        },
-        { $set: { statusUpdatedAt: doc.bookingDate } },
-        { new: true }
-      );
-      console.log(order, "initial status from shipper");
-    }
-    return { code: 200 };
-  } catch (err) {
-    console.log("err", err);
-    return { code: 400 };
-  }
-});
-
-module.exports = model("Checkpoint", CheckpointSchema);

package/models/City.js

@@ -1,17 +0,0 @@
-const { Schema, model } = require("mongoose");
-
-const CitySchema = new Schema(
-  {
-    cityName: { type: String, default: "" },
-    correctedCityName: { type: String, default: "" },
-    cityCode: { type: String, default: "" },
-    area: { type: String, default: "" },
-    shipperType: { type: String, default: "" },
-    webCityId: { type: String, default: "" },
-    hubId: { type: String, default: "" },
-    body: {},
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = model("City", CitySchema);

package/models/Column.js

@@ -1,28 +0,0 @@
-const mongoose = require("mongoose");
-
-const columnSchema = new mongoose.Schema(
-  {
-    title: {
-      type: String,
-      required: true,
-    },
-    position: {
-      type: Number,
-      required: true,
-    },
-    deleted: {
-      type: Boolean,
-      default: false,
-    },
-    workspaceId: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-columnSchema.virtual("cardList", {
-  ref: "Card",
-  localField: "_id", // Change to '_id' to match the column's '_id'
-  foreignField: "columnId",
-});
-
-module.exports = mongoose.model("Column", columnSchema);

package/models/Conversation.js

@@ -1,84 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const draftSchema = new mongoose.Schema({
-  _id: {
-    type: Schema.Types.ObjectId,
-    default: () => new mongoose.Types.ObjectId(),
-  },
-  messageBody: {},
-  createdBy: { type: Schema.Types.ObjectId, ref: "User" },
-});
-
-const conversationSchema = new mongoose.Schema(
-  {
-    platformType: {
-      type: String,
-      enum: [
-        "gmail",
-        "instagram",
-        "whatsapp",
-        "linkedin",
-        "facebook",
-        "tiktok",
-        "webChat",
-        "smtp_gmail",
-      ],
-      required: true,
-    },
-    members: [{ type: Schema.Types.ObjectId, ref: "User" }],
-    conversationType: {
-      type: String,
-      enum: ["comment", "message", "email"],
-      required: true,
-    },
-    messageCount: { type: Number, default: 0 },
-    conversationStatus: {
-      type: String,
-      enum: ["assigned", "unassigned", "archived"],
-      required: true,
-      default: "unassigned",
-    },
-    assignId: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    platformId: {
-      type: Schema.Types.ObjectId,
-      ref: "Integration",
-      default: null,
-    },
-    labels: [{ type: Schema.Types.ObjectId, ref: "Label" }],
-    title: { type: String },
-    platformTimestamp: { type: String, default: "" },
-    status: {
-      type: String,
-      enum: ["open", "processing", "hold", "closed"],
-      required: true,
-      default: "open",
-    },
-    isSpam: { type: Boolean, default: false },
-    threadId: { type: String, default: "" },
-    messageId: { type: String, default: "" },
-    profileId: { type: Schema.Types.ObjectId, ref: "Profile" },
-    conversationCloseTime: { type: String },
-    workspaceId: { type: Schema.Types.ObjectId, ref: "Workspace" },
-    postId: { type: String, default: "" },
-    postUrl: { type: String, default: "" },
-    sender: { type: String, default: "" },
-    reasonForClosing: {
-      reason: { type: String, default: "" },
-      closedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    },
-    integratedAccount: { type: String, default: "" },
-    isRead: { type: Boolean, default: false },
-    ticketId: { type: String, default: "" },
-    draft: [draftSchema],
-    isWebchatTicket: { type: Boolean, default: false },
-    webchatComplaintType: { type: String, default: null },
-    isComposed: { type: Boolean, default: false },
-    utilityMessage: [],
-    orderId: [],
-    isFetch: { type: Boolean, default: true },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = mongoose.model("Conversation", conversationSchema);

package/models/Customer.js

@@ -1,35 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const CustomerSchema = new Schema(
-  {
-    name: { type: String, default: "" },
-    email: { type: String, default: "" },
-    phone: { type: String, default: "" },
-    city: { type: String, default: "" },
-    defaultAddress: { type: String, default: "" },
-    currentShippingAddress: {},
-    addresses: [],
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-    phone1: { type: String, default: "" },
-    isBlackListed: { type: Boolean, default: false },
-    createdBy: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-    },
-    updatedBy: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-    },
-    isDeleted: { type: Boolean, default: false },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-const Customer = mongoose.model("Customer", CustomerSchema);
-
-module.exports = Customer;

package/models/DescriptionTemplate.js

@@ -1,22 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-const DescriptionTemplateSchema = new Schema(
-  {
-    name: { type: String, default: "" },
-    subject: { type: String, default: "" },
-    format: { type: String, default: "" },
-    workspaceId: { type: String, default: "" },
-    businessId: { type: String, default: "" },
-    integrationId: { type: String, default: "" },
-    type: { type: String, default: "" },
-    body: {},
-    arbitraryValues: {},
-    moduleType: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-const DescriptionTemplate =
-  mongoose.models.DescriptionTemplate ||
-  mongoose.model("DescriptionTemplate", DescriptionTemplateSchema);
-
-module.exports = DescriptionTemplate;

package/models/Integration.js

@@ -1,53 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const IntegrationSchema = new mongoose.Schema(
-  {
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-    type: {
-      type: String,
-      enum: [
-        "socialPlatforms",
-        "whatsapp",
-        "gmail",
-        "sms",
-        "map",
-        "facebook",
-        "instagram",
-        "webChat",
-        "smtp_gmail",
-      ],
-    },
-    chatbot: { type: Boolean, default: false },
-    isNlp: { type: Boolean, default: false },
-    autoTicket: {
-      enabled: { type: Boolean, default: false },
-    },
-    signature: {
-      type: Map,
-      of: mongoose.Schema.Types.Mixed,
-      default: {},
-    },
-    chatbotId: { type: Schema.Types.ObjectId, ref: "Chatbot", default: null },
-    members: [
-      {
-        type: Schema.Types.ObjectId,
-        ref: "User",
-      },
-    ],
-    body: {},
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-IntegrationSchema.virtual("conversations", {
-  ref: "Conversation",
-  localField: "_id",
-  foreignField: "platformId",
-});
-
-module.exports = mongoose.model("Integration", IntegrationSchema);

package/models/Label.js

@@ -1,42 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const LabelSchema = new Schema(
-  {
-    color: { type: String },
-    title: {
-      type: String,
-      required: true,
-    },
-    type: {
-      type: String,
-      required: true,
-      default: "system",
-      enum: ["system", "custom", "escalation"],
-    },
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-    },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-LabelSchema.virtual("conversationCount", {
-  ref: "Conversation",
-  localField: "_id",
-  foreignField: "labels",
-  count: true,
-});
-
-LabelSchema.virtual("conversations", {
-  ref: "Conversation",
-  localField: "_id",
-  foreignField: "labels",
-});
-
-LabelSchema.set("toObject", { virtuals: true });
-LabelSchema.set("toJSON", { virtuals: true });
-
-const Label = mongoose.model("Label", LabelSchema);
-
-module.exports = Label;

package/models/Message.js

@@ -1,47 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const readBySchema = new Schema({
-  receiptTrigger: { type: Boolean, default: false },
-  readerId: { type: Schema.Types.ObjectId, ref: "User", default: null },
-  readTime: { type: String, default: "" },
-  responseTime: { type: String, default: "" },
-});
-
-const newMessageSchema = new mongoose.Schema(
-  {
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-    readBy: [readBySchema],
-    messageType: {
-      type: String,
-      enum: [
-        "system",
-        "user",
-        "internal",
-        "chatbot",
-        "auto-generated",
-        "facebook",
-        "instagram",
-        "webChat",
-        "chat-status",
-      ],
-      required: true,
-    },
-    conversationId: {
-      type: Schema.Types.ObjectId,
-      ref: "Conversation",
-      default: null,
-    },
-    conversationType: { type: String },
-    activityId: { type: String, default: "" },
-
-    body: {},
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = mongoose.model("Message", newMessageSchema);

package/models/Order.js

@@ -1,131 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-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: "" },
-  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(
-  {
-    customerId: { type: Schema.Types.ObjectId, ref: "Customer", default: null },
-    swap: { type: String, default: "" },
-    shipperInformation: ShipperInformation,
-    trackingId: { type: String, default: "" },
-    cityName: { 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 },
-    customerName: { type: String, default: "" },
-    customerPhone: { type: String, default: "" },
-    customerAddress: { type: String, default: "" },
-    discountPercentage: { type: Number, default: 0 },
-    discountValue: { type: Number, default: 0 },
-    productDetails: { type: String, default: "" },
-    webOrderId: { type: String, default: "" },
-    webOrderNumber: { type: String, default: "" },
-    fulfillmentStatus: { type: String, default: "" },
-    webFulfillmentId: { type: String, default: "" },
-    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 },
-    orderNumber: { type: String, default: "" },
-    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 },
-    isBulk: { type: String, default: "" },
-    priority: { 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 },
-    platformFinancialStatus: { type: String, default: "pending" },
-    payment: {},
-    credentials: {},
-  },
-  { 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",
-});
-
-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);