picker-db 3.4.0

package/modules/picker/schemas/business.js

@@ -0,0 +1,231 @@
+const { TYPES } = require("../../../constants").BUSINESS;
+const { DEVICE_TYPES } = require("../../../constants").USER;
+const { PAYMENT_METHODS } = require("../../../constants");
+
+const FareSettingsSchema = require("./fareSettings");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const WebhookSchema = new connection.base.Schema({
+    url: {
+      type: String,
+      required: true,
+    },
+    type: {
+      type: String,
+      required: true,
+    },
+  }, { timestamps: false, _id: false });
+
+  const ScheduleSchema = new connection.base.Schema({
+    day: {
+      type: Number,
+      required: true,
+    },
+    open: {
+      type: String,
+      required: false,
+    },
+    close: {
+      type: String,
+      required: false,
+    },
+    isOpen: {
+      type: Boolean,
+      required: true,
+    },
+  }, { _id: false });
+
+  const SettingsSchema = new connection.base.Schema({
+    maxDeliveryDistance: {
+      type: Number,
+      min: 0,
+      max: 100,
+    }, // In kms
+    commission: {
+      type: Number,
+      min: 0,
+      max: 100,
+    }, // Percentage
+    searchMaxDistance: {
+      type: Number,
+      min: 0,
+      max: 100,
+    }, // In kms. For driver search
+    personalizedSMR: {
+      type: Boolean,
+    },
+    deliveryFee: {
+      type: {
+        type: String,
+      },
+      value: {
+        type: Number,
+      },
+    },
+  }, { _id: false, timestamps: false });
+
+  const BusinessSchema = new connection.base.Schema({
+    companyMobile: {
+      type: String,
+      index: true,
+      trim: true,
+      sparse: true,
+    },
+    companyCountryCode: { type: String },
+    companyFullMobile: {
+      type: String,
+      index: true,
+    },
+
+    companyName: { type: String },
+    businessCategories: [{
+      type: connection.base.Schema.ObjectId,
+      ref: "BusinessCategory",
+    }],
+    storeType: {
+      type: String,
+      required: true,
+      enum: [
+        TYPES.EXTERNAL,
+        TYPES.MARKETPLACE,
+        TYPES.SHOP_ORDER,
+      ],
+      default: TYPES.MARKETPLACE,
+    },
+    schedule: { type: [ScheduleSchema] },
+    tags: [{ type: String }],
+    // #region Verification control
+    isEmailVerified: {
+      type: Boolean,
+      default: false,
+      required: true,
+    },
+    emailVerificationToken: {
+      type: String,
+      required: false,
+    },
+    emailVerificationTokenUpdatedAt: {
+      type: Date,
+    },
+    otpResendTimes: { type: Number, max: 3 },
+    // #endregion Verification control
+
+    frontImage: {
+      thumbnail: { type: String, default: null },
+      original: { type: String, default: null },
+    },
+    // #region Location
+    latitude: {
+      type: Number,
+      default: null,
+    },
+    longitude: {
+      type: Number,
+      default: null,
+    },
+    fullAddress: { type: String },
+    // #endregion Location
+
+    avgTime: {
+      value: {
+        type: Number,
+        default: 0,
+      },
+      text: {
+        type: String,
+        default: "",
+      },
+    },
+
+    // #region Device information
+    deviceType: {
+      type: String,
+      enum: [
+        DEVICE_TYPES.IOS,
+        DEVICE_TYPES.ANDROID,
+        DEVICE_TYPES.WEB,
+      ],
+    },
+    appVersion: { type: String },
+    deviceToken: {
+      type: String,
+      trim: true,
+      index: true,
+      sparse: true,
+    },
+    // #endregion Device information
+
+    productTypes: [{
+      type: String,
+    }],
+
+    // #region Approval information
+    approvedBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    rejectedBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    approvedDate: {
+      type: Date,
+    },
+    rejectedDate: {
+      type: Date,
+    },
+    // #endregion Approval information
+
+    status: {
+      type: String,
+    },
+    onDutyFlag: {
+      type: Boolean,
+      default: true,
+    },
+    fareSettings: [FareSettingsSchema(connection)],
+    totalRatingPoints: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    totalRatingCount: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    totalBookingsCompleted: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    totalApprovedProducts: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    dynamicLink: {
+      type: String,
+    },
+    aditionalInfo: {
+      type: String,
+    },
+    webhooks: [WebhookSchema],
+    smrVia: [String],
+    paymentMethod: {
+      type: String,
+      required: true,
+      enum: [
+        PAYMENT_METHODS.CARD.TEXT,
+        PAYMENT_METHODS.CASH.TEXT,
+        PAYMENT_METHODS.BOTH.TEXT,
+      ],
+      default: PAYMENT_METHODS.CARD.TEXT,
+    },
+    settings: SettingsSchema,
+
+  }, { timestamps: true });
+
+  return BusinessSchema;
+};

package/modules/picker/schemas/businessCategory.js

@@ -0,0 +1,61 @@
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const namesSchema = new connection.base.Schema({
+    text: { type: String },
+    lang: { type: String },
+  }, { _id: false });
+
+  const BusinessCategorySchema = new connection.base.Schema({
+    name: {
+      type: String,
+      required: true,
+    },
+    image: {
+      thumbnail: {
+        type: String,
+        default: null,
+      },
+      original: {
+        type: String,
+        default: null,
+      },
+    },
+    order: {
+      type: Number,
+      default: 100,
+    },
+    isDeleted: {
+      type: Boolean,
+      default: false,
+    },
+    tag: {
+      type: String,
+    },
+    productTypes: [{
+      type: String,
+    }],
+    commission: {
+      type: Number,
+      required: true,
+      min: 0,
+      max: 100,
+    },
+    names: [
+      namesSchema,
+    ],
+    superRegions: [{
+      type: connection.base.Schema.ObjectId,
+      ref: "SuperRegion",
+    }],
+    isVisible: {
+      type: Boolean,
+      default: true,
+    },
+    showClosedBusinesses: {
+      type: Boolean,
+      default: true,
+    },
+  }, { timestamps: true });
+
+  return BusinessCategorySchema;
+};

package/modules/picker/schemas/customer.js

@@ -0,0 +1,28 @@
+const { DEVICE_TYPES } = require("../../../constants").USER;
+
+const FareSettingsSchema = require("./fareSettings");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const CustomerSchema = new connection.base.Schema({
+    deviceType: {
+      type: String,
+      enum: [
+        DEVICE_TYPES.IOS,
+        DEVICE_TYPES.ANDROID,
+        DEVICE_TYPES.WEB,
+      ],
+    },
+    appVersion: { type: String },
+    deviceToken: {
+      type: String,
+      trim: true,
+      index: true,
+      sparse: true,
+    },
+    tag: { type: String },
+    fareSettings: [FareSettingsSchema(connection)],
+  }, { timestamps: true });
+
+  return CustomerSchema;
+};

package/modules/picker/schemas/driver.js

@@ -0,0 +1,162 @@
+const { PAYMENT, TYPE, ACCOUNTING_TYPE } = require("../../../constants").DRIVER;
+const { DEVICE_TYPES } = require("../../../constants").USER;
+const { VEHICLE_TYPES } = require("../../../constants");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const DriverSchema = new connection.base.Schema({
+    currentDriverLocation: {
+      type: { type: String, default: "Point" },
+      coordinates: { type: [Number], default: [0, 0] },
+    },
+    deviceType: {
+      type: String,
+      enum: [
+        DEVICE_TYPES.IOS,
+        DEVICE_TYPES.ANDROID,
+        DEVICE_TYPES.WEB,
+      ],
+    },
+    appVersion: { type: String },
+    deviceToken: {
+      type: String,
+      trim: true,
+      index: true,
+      sparse: true,
+    },
+    vehicleType: {
+      type: String,
+      default: null,
+    },
+    carType: {
+      type: Number,
+      enum: [
+        VEHICLE_TYPES.BIKE.INDEX,
+        VEHICLE_TYPES.LITE.INDEX,
+      ],
+    },
+    vehicleColor: {
+      type: String,
+      default: null,
+    },
+    vehicleYear: { type: Number },
+    MCNumber: {
+      type: String,
+      unique: true,
+    },
+    vehicleModelName: { type: String },
+    onDutyFlag: {
+      type: Boolean,
+      default: false,
+    },
+    lastOnDutyFlagTime: { type: Date },
+    isActive: {
+      type: Boolean,
+      default: false,
+      required: true,
+    },
+    tag: {
+      type: String,
+      default: "",
+    },
+    payment: {
+      type: {
+        type: String,
+        enum: [
+          PAYMENT.PERCENTAGE,
+          PAYMENT.ABSOLUTE,
+          PAYMENT.OVER_MINIMUM,
+          PAYMENT.PERCENTAGE_MINIMUM,
+          PAYMENT.ABSOLUTE_MINIMUM,
+        ],
+        default: PAYMENT.ABSOLUTE,
+      },
+      value: {
+        type: Number,
+        default: 4,
+      },
+    },
+    batteryPercentage: {
+      type: Number,
+      default: null,
+    },
+    batteryStatus: {
+      type: Number,
+      enum: [1, 2, 3, 4, 5, null],
+      default: null,
+    },
+    totalPickerPoints: {
+      type: Number,
+    },
+    type: {
+      type: String,
+      enum: [
+        TYPE.STARTER,
+        TYPE.SENIOR,
+        TYPE.MCGYVER,
+        TYPE.PREMIUM,
+      ],
+      default: TYPE.STARTER,
+    },
+    paymentBalance: {
+      type: Number,
+    },
+    wallet: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    bookingsCompleted: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    // ACCOUNTING DATA
+    paymentMethod: {
+      type: String,
+      default: null,
+    },
+    workBalance: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    accountingType: {
+      type: String,
+      enum: [
+        ACCOUNTING_TYPE.OLD,
+        ACCOUNTING_TYPE.NEW,
+      ],
+    },
+    // Personal information
+    personalInformation: {
+      profession: { type: String },
+      professionTime: { type: String },
+      review: { type: String },
+      linkedin: { type: String },
+      firstName: { type: String },
+    },
+    approvedBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    approvedDate: {
+      type: Date,
+    },
+    geoSparkToken: {
+      type: String,
+    },
+    automaticAcceptation: {
+      type: Boolean,
+      default: false,
+    },
+    validatedOTP: {
+      type: Boolean,
+    },
+    lastOTPValidation: {
+      type: Date,
+    },
+  }, { timestamps: true });
+
+  return DriverSchema;
+};

package/modules/picker/schemas/fareSettings.js

@@ -0,0 +1,122 @@
+
+const _ = require("lodash");
+
+const KmRangeSchema = require("./kmRange");
+
+const { VEHICLE_TYPES } = require("../../../constants");
+const { RUSH_HOUR_INCREASE_TYPES } = require("../../../constants").FARE;
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const FareSettingsSchema = new connection.base.Schema({
+    distanceRange: {
+      type: Number,
+      required: true,
+      min: 0,
+    },
+    baseFare: {
+      type: Number,
+      min: 0,
+    },
+    perKmCharge: {
+      type: Number,
+      min: 0,
+    },
+    perMinuteCharge: {
+      type: Number,
+      min: 0,
+    },
+    baseDistance: {
+      type: Number,
+      min: 0,
+    },
+    freeTime: {
+      type: Number,
+      min: 0,
+    },
+    averageTime: {
+      type: Number,
+      min: 0,
+    },
+    carType: {
+      type: Number,
+      enum: [
+        VEHICLE_TYPES.BIKE.INDEX,
+        VEHICLE_TYPES.LITE.INDEX,
+      ],
+      index: true,
+      unique: false,
+    },
+    carName: {
+      type: String,
+      enum: [
+        VEHICLE_TYPES.BIKE.TEXT,
+        VEHICLE_TYPES.LITE.TEXT,
+      ],
+    },
+    cancellationPolicy: {
+      type: String,
+      default: null,
+    },
+    cancellationFreeTimeInSecond: {
+      type: Number,
+      default: 0,
+    },
+    minimumCancellationFee: {
+      type: Number,
+      default: 1,
+    },
+    commissionCharge: {
+      type: Number,
+      default: 25,
+    },
+    notShowTimeLimit: { // In seconds
+      type: Number,
+      default: 10,
+    },
+    notShowCustomerCharge: {
+      type: Number,
+      default: 0.50,
+    },
+    notShowDriverCommission: {
+      type: Number,
+      default: 0.50,
+    },
+    regionID: {
+      type: connection.base.Schema.ObjectId,
+      ref: "Region",
+      default: null,
+      index: true,
+      sparse: true,
+    },
+    superRegionID: {
+      type: connection.base.Schema.ObjectId,
+      ref: "SuperRegion",
+      default: null,
+      index: true,
+      sparse: true,
+    },
+    kmRanges: [KmRangeSchema(connection)],
+    rainCharge: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    rushHourIncreaseType: {
+      type: String,
+      enum: _.values(RUSH_HOUR_INCREASE_TYPES),
+    },
+    rushHourIncreaseCoefficient: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    rushHourIncrementAmount: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+  }, { _id: false });
+
+  return FareSettingsSchema;
+};

package/modules/picker/schemas/fraudBooking.js

@@ -0,0 +1,21 @@
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const FraudBookingSchema = new connection.base.Schema({
+    bookingID: {
+      type: connection.base.Schema.ObjectId,
+      ref: "Bookings",
+      index: true,
+    },
+    registeredBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+      index: true,
+      sparse: true,
+    },
+    reasons: [{
+      type: String,
+    }],
+  }, { timestamps: true });
+
+  return FraudBookingSchema;
+};

package/modules/picker/schemas/identityCounter.js

@@ -0,0 +1,10 @@
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const CounterSchema = new connection.base.Schema({
+    model: { type: String, required: true, index: true },
+    field: { type: String, required: true },
+    count: { type: Number, default: 0 },
+  });
+
+  return CounterSchema;
+};

package/modules/picker/schemas/kmRange.js

@@ -0,0 +1,27 @@
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  // #region Internal Schemas
+  const KmRangeSchema = new connection.base.Schema({
+    min: {
+      type: Number,
+      min: 0,
+      max: 1000,
+      default: 0,
+    },
+    max: {
+      type: Number,
+      min: 0,
+      max: 1000,
+      default: 100,
+    },
+    amount: {
+      type: Number,
+      min: 0,
+      max: 1000,
+      default: 0,
+    },
+  }, { _id: false });
+
+  return KmRangeSchema;
+};