shuttlepro-shared 1.3.13 → 1.3.14

package/models/Shipper.js

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

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

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

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

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

@@ -1,25 +0,0 @@
-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/UserWorkflow.js

@@ -1,46 +0,0 @@
-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/Workspace.js

@@ -1,308 +0,0 @@
-const mongoose = require("mongoose");
-//TODO: task manager and default location creation
-const shiftSchema = new mongoose.Schema(
-  {
-    shiftName: {
-      type: String,
-      required: true,
-    },
-    days: [
-      {
-        day: { type: String, required: true },
-        startTime: { type: String, required: true },
-        endTime: { type: String, required: true },
-        breakStartTime: { type: String, required: false },
-        breakEndTime: { type: String, required: false },
-        lateThreshold: { type: String, required: false },
-      },
-    ],
-  },
-  { _id: true }
-);
-const scoreThresholdSchema = new mongoose.Schema({
-  operator: {
-    type: mongoose.Schema.Types.Mixed,
-    required: false,
-  },
-  value: {
-    type: mongoose.Schema.Types.Mixed,
-    required: true,
-  },
-  score: {
-    type: Number,
-    required: false,
-  },
-  additionalFields: {
-    type: mongoose.Schema.Types.Mixed,
-    default: {},
-  },
-});
-const kpiSchema = new mongoose.Schema({
-  weight: {
-    type: Number,
-    required: true,
-  },
-  scoreThresholds: {
-    type: [scoreThresholdSchema],
-    default: [],
-  },
-  relativeGrading: {
-    type: Boolean,
-    default: false,
-  },
-});
-const ReasonSchema = new mongoose.Schema({
-  _id: {
-    type: mongoose.Schema.Types.ObjectId,
-    default: null,
-  },
-  reason: { type: String, required: true },
-  color: { type: String, default: "#000000" },
-  categoryTitle: { type: String, required: true },
-});
-const ResolutionReasonCategorySchema = new mongoose.Schema({
-  _id: {
-    type: mongoose.Schema.Types.ObjectId,
-    default: null,
-  },
-  title: { type: String, required: true },
-  reasons: { type: [ReasonSchema], default: [] },
-});
-const feedbackFormSchema = new mongoose.Schema({
-  formName: { type: String, required: true, trim: true },
-  brandName: { type: String, default: "" },
-  brandLogoUrl: { type: String, default: "", trim: true },
-  type: {
-    type: String,
-    default: "conversation",
-    enum: [
-      "conversation",
-      "shop",
-      // "order"
-    ],
-  },
-  qr: [
-    {
-      type: mongoose.Schema.Types.Mixed,
-      default: {
-        data: "",
-        code: "",
-        link: "",
-        shopId: "",
-      },
-    },
-  ],
-  integrationId: [
-    {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Integration",
-      default: null,
-    },
-  ],
-  enabled: {
-    type: Boolean,
-    default: true,
-  },
-  fields: [
-    {
-      fieldName: {
-        type: String,
-        required: true,
-        trim: true,
-      },
-      required: {
-        type: Boolean,
-        default: false,
-      },
-      enabled: {
-        type: Boolean,
-        default: true,
-      },
-      createdBy: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "User",
-        default: null,
-      },
-      updatedBy: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "User",
-        default: null,
-      },
-      fieldType: {
-        type: String,
-        enum: [
-          "text",
-          "autocomplete",
-          "radio",
-          "text area",
-          "number",
-          "date",
-          "time",
-          "email",
-          "range",
-          "url",
-          "colour",
-          "file",
-          "starRating",
-          "heading",
-          "paragraph",
-        ],
-      },
-      option: {
-        type: mongoose.Schema.Types.Mixed,
-      },
-    },
-  ],
-});
-const workspaceSchema = new mongoose.Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-      trim: true,
-    },
-    iconUrl: { type: String, default: "" },
-    thumbUrl: { type: String, default: "" },
-    createdBy: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-      default: null,
-    },
-    updatedBy: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-      default: null,
-    },
-    productsCount: { type: Number, default: 0 },
-    ordersCount: { type: Number, default: 0 },
-    shippers: [{ type: String, trim: true }],
-    socialProfiles: [],
-    shiftConfigurations: [shiftSchema],
-    kpiConfiguration: {
-      type: Map,
-      of: kpiSchema,
-      default: {},
-    },
-    members: [],
-    contact: String,
-    email: String,
-    address: String,
-    websiteUrl: String,
-    facebookUrl: String,
-    twitterUrl: String,
-    instagramUrl: String,
-    isDeleted: { type: Boolean, default: false },
-    businessHours: {
-      startTime: { type: String, default: "" },
-      endTime: { type: String, default: "" },
-    },
-    remarks: [
-      {
-        reason: { type: String, default: "" },
-        type: { type: String, default: "" },
-        color: { type: String, default: "" },
-      },
-    ],
-    chatGptApiKey: String,
-    skuSeparator: { type: String, default: "-" },
-    uniqueNo: { type: Number, default: 0 },
-    webhookStatus: { type: String, default: "" },
-    businessCategory: { type: String, default: "" },
-    numberOfProducts: { type: Number, default: 0 },
-    monthlyOrders: { type: Number, default: 0 },
-    queueTracking: { type: Boolean, default: false },
-    orderConfiguration: { type: String, default: "" },
-    defaultModule: { type: String, default: "dashboard" },
-    resolutionReasonCategories: {
-      type: [ResolutionReasonCategorySchema],
-      default: [],
-    },
-    feedbackDynamicFields: [feedbackFormSchema],
-    dynamicFieldsTemplate: [
-      {
-        groupName: { type: String, required: true, trim: true },
-        fields: [
-          {
-            fieldName: {
-              type: String,
-              required: true,
-              trim: true,
-            },
-            required: {
-              type: Boolean,
-              default: false,
-            },
-            enabled: {
-              type: Boolean,
-              default: true,
-            },
-            createdBy: {
-              type: mongoose.Schema.Types.ObjectId,
-              ref: "User",
-              default: null,
-            },
-            updatedBy: {
-              type: mongoose.Schema.Types.ObjectId,
-              ref: "User",
-              default: null,
-            },
-            fieldType: {
-              type: String,
-              enum: [
-                "text",
-                "autocomplete",
-                "radio",
-                "text area",
-                "number",
-                "date",
-                "time",
-                "email",
-                "range",
-                "url",
-                "colour",
-                "file",
-              ],
-            },
-            option: {
-              type: mongoose.Schema.Types.Mixed,
-            },
-            isPublic: {
-              type: Boolean,
-              default: false,
-            },
-          },
-        ],
-      },
-    ],
-    crmVisibility: {
-      type: String,
-      enum: ["everyone", "assignee"],
-      default: "everyone",
-    },
-    defaultShift: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-const commonOptions = {
-  type: String,
-  trim: true,
-  default: "",
-};
-workspaceSchema.add({
-  contact: commonOptions,
-  email: commonOptions,
-  address: commonOptions,
-  websiteUrl: commonOptions,
-  facebookUrl: commonOptions,
-  twitterUrl: commonOptions,
-  instagramUrl: commonOptions,
-  chatGptApiKey: commonOptions,
-});
-
-workspaceSchema.virtual("integrations", {
-  ref: "Integration",
-  localField: "_id",
-  foreignField: "workspaceId",
-});
-const Workspace = mongoose.model("Workspace", workspaceSchema);
-module.exports = Workspace;