picker-db 3.4.0

package/modules/picker/schemas/massDelivery.js

@@ -0,0 +1,119 @@
+
+const { STATUSES } = require("../../../constants").MASS_DELIVERY;
+const { getModel } = require("../models/identityCounter");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const IdentityCounterModel = getModel(connection);
+
+  const MassDeliverySchema = new connection.base.Schema({
+    massDeliveryID: {
+      type: Number,
+      index: true,
+    },
+    business: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    businessName: {
+      type: String,
+    },
+    driver: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    driverName: {
+      type: String,
+    },
+    totalDeliveryFee: {
+      type: Number,
+      min: 0,
+      max: 10000,
+    },
+    totalDistance: {
+      type: Number,
+      min: 0,
+      max: 10000,
+    },
+    totalLocations: {
+      type: Number,
+      min: 0,
+      max: 1000,
+    },
+    totalTime: {
+      type: Number,
+      min: 0,
+    },
+    totalOrderAmount: {
+      type: Number,
+      min: 0,
+      max: 1000,
+    },
+    totalSMR: {
+      type: Number,
+      min: 0,
+    },
+    currentStatus: {
+      type: Number,
+      index: true,
+      enum: [
+        STATUSES.PENDING.INDEX,
+        STATUSES.ONGOING.INDEX,
+        STATUSES.COMPLETED.INDEX,
+        STATUSES.CANCELLED.INDEX,
+      ],
+      default: STATUSES.PENDING.INDEX,
+    },
+    statusText: {
+      type: String,
+      enum: [
+        STATUSES.PENDING.TEXT,
+        STATUSES.ONGOING.TEXT,
+        STATUSES.COMPLETED.TEXT,
+        STATUSES.CANCELLED.TEXT,
+      ],
+      default: STATUSES.PENDING.TEXT,
+    },
+    startAt: {
+      type: Date,
+      default: Date.now(),
+    },
+    endAt: {
+      type: Date,
+    },
+    request: {
+      type: JSON,
+    },
+    fileUrl: {
+      type: String,
+    },
+    completedBookings: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    totalBookings: {
+      type: Number,
+      min: 0,
+    },
+  }, { timestamps: true });
+
+  MassDeliverySchema.pre("save", function (next) {
+    if (!this.isNew) {
+      return next();
+    }
+    const doc = this;
+    const query = { model: "MassDelivery" };
+    const update = { $inc: { count: 1 } };
+    const options = { new: true };
+    IdentityCounterModel.findOneAndUpdate(query, update, options, function (error, counter) {
+      if (error) {
+        return next(error);
+      }
+      doc.massDeliveryID = counter.count;
+      next();
+    });
+  });
+
+  return MassDeliverySchema;
+};

package/modules/picker/schemas/notification.js

@@ -0,0 +1,76 @@
+const { VIA, PROVIDERS } = require("../../../constants").NOTIFICATION;
+const _ = require("lodash");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const NotificationSchema = new connection.base.Schema({
+    notificationUserID: [{
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+      index: true,
+      sparse: true,
+    }],
+    eventID: {
+      type: String,
+      index: true,
+      sparse: true,
+    }, // ID of the event that triggered the notification
+    eventType: {
+      type: String,
+      index: true,
+    }, // Notification type
+    title: { type: String },
+    message: { type: String },
+    messageHtml: { type: String }, // Html version of the message
+    provider: {
+      type: String,
+      index: true,
+      sparse: true,
+    },
+    via: {
+      type: String,
+      required: true,
+      index: true,
+      sparse: true,
+      enum: _.keys(VIA),
+    },
+    sentStatus: {
+      type: String,
+      enum: ["success", "failed"],
+      index: true,
+      sparse: true,
+    },
+    isAdminNotification: {
+      type: Boolean,
+      default: false,
+      index: true,
+      sparse: true,
+    },
+    isRead: {
+      type: Boolean,
+      default: false,
+    },
+    isDeleted: {
+      type: Boolean,
+      default: false,
+    },
+    data: {
+      type: JSON,
+    }, // Data sent as notification
+    error: {
+      type: String,
+    },
+    providerID: {
+      type: String,
+      index: true,
+      sparse: true,
+    },
+    deviceToken: {
+      type: String,
+      index: true,
+      sparse: true,
+    },
+  }, { timestamp: true });
+
+  return NotificationSchema;
+};

package/modules/picker/schemas/paymentezCustomer.js

@@ -0,0 +1,41 @@
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const PaymentezCustomerSchema = new connection.base.Schema({
+    user: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    type: {
+      type: String,
+    },
+    token: {
+      type: String,
+      required: true,
+    },
+    transaction_reference: {
+      type: String,
+      default: null,
+    },
+    isDefault: {
+      type: Boolean,
+      default: 0,
+    },
+    taxPercentage: {
+      type: Number,
+      min: 0,
+      max: 1,
+      default: 0,
+    },
+    platform: {
+      type: String,
+    },
+    cardType: {
+      type: String,
+    },
+    bin: {
+      type: String,
+    },
+  }, { timestamps: true });
+
+  return PaymentezCustomerSchema;
+};

package/modules/picker/schemas/paymentezTransaction.js

@@ -0,0 +1,67 @@
+const { PAYMENT_METHODS } = require("../../../constants");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const PaymentezTransactionSchema = new connection.base.Schema({
+    customerId: {
+      type: connection.base.Schema.ObjectId,
+      ref: "PaymentezCustomer",
+    },
+    trxId: {
+      type: String,
+      required: false,
+      default: null,
+    },
+    type: {
+      type: String,
+    },
+    amount: {
+      type: Number,
+    },
+    paymentMethod: {
+      type: String,
+      required: false,
+      enum: [
+        PAYMENT_METHODS.CARD.TEXT,
+        PAYMENT_METHODS.CASH.TEXT,
+      ],
+    },
+    authCode: {
+      type: String,
+    },
+    bookingID: {
+      type: connection.base.Schema.ObjectId,
+      ref: "Bookings",
+    },
+    status: {
+      type: String,
+    },
+    message: {
+      type: String,
+    },
+    statusDetail: {
+      type: String,
+    },
+    taxCharge: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    registeredBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    }, // Reference to the user who realized the transaction
+    refundedBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    }, // Reference to the user who realized the refund
+    refundDate: {
+      type: Date,
+    },
+    refundError: {
+      type: String,
+    },
+  }, { timestamps: true });
+
+  return PaymentezTransactionSchema;
+};

package/modules/picker/schemas/preference.js

@@ -0,0 +1,40 @@
+const {
+  PAYMENT_METHODS,
+  VEHICLE_TYPES,
+} = require("../../../constants");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const PreferenceSchema = new connection.base.Schema({
+    paymentMethod: {
+      type: String,
+      default: null,
+      enum: [
+        PAYMENT_METHODS.CASH.TEXT,
+        PAYMENT_METHODS.CARD.TEXT,
+        PAYMENT_METHODS.NONE.TEXT,
+      ],
+      default: PAYMENT_METHODS.CARD.TEXT,
+    },
+    carName: {
+      type: String,
+      default: null,
+      enum: [
+        VEHICLE_TYPES.BIKE.TEXT,
+        VEHICLE_TYPES.LITE.TEXT,
+        VEHICLE_TYPES.NONE.TEXT,
+      ],
+      default: VEHICLE_TYPES.BIKE.TEXT,
+    },
+    user_id: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    language: {
+      type: String,
+      default: "es",
+    },
+  }, { timestamps: true });
+
+  return PreferenceSchema;
+};

package/modules/picker/schemas/pricingDetails.js

@@ -0,0 +1,90 @@
+const _ = require("lodash");
+
+const { RUSH_HOUR_INCREASE_TYPES } = require("../../../constants").FARE;
+
+const KmRangeSchema = require("./kmRange");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const PricingDetailsSchema = new connection.base.Schema({
+    baseFare: {
+      type: Number,
+      required: true,
+      min: 0,
+    },
+    perKmCharge: {
+      type: Number,
+      required: true,
+      min: 0,
+    },
+    perMinuteCharge: {
+      type: Number,
+      required: true,
+      min: 0,
+    },
+    freeTime: {
+      type: Number,
+      required: true,
+      min: 0,
+    },
+    baseDistance: {
+      type: Number,
+      required: true,
+      min: 0,
+    },
+    averageTime: {
+      type: Number,
+      required: true,
+      min: 0,
+    }, // IN SECONDS
+    kmRanges: [KmRangeSchema(connection)],
+    notShowTimeLimit: {
+      type: Number,
+      default: 10,
+    }, // IN SECONDS
+    notShowCustomerCharge: {
+      type: Number,
+      default: 0.50,
+    },
+    notShowDriverCommission: {
+      type: Number,
+      default: 0.50,
+    },
+    cancellationPolicy: {
+      type: String,
+      default: null,
+    },
+    cancellationFreeTimeInSecond: {
+      type: Number,
+      default: 0,
+    },
+    minimumCancellationFee: {
+      type: Number,
+      default: 1,
+    },
+    rainCharge: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    specialFeesActive: [{
+      type: String,
+    }],
+    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 PricingDetailsSchema;
+};

package/modules/picker/schemas/referralUsage.js

@@ -0,0 +1,33 @@
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const ReferralUsageSchema = new connection.base.Schema({
+    referralPattern: {
+      type: String,
+      requied: true,
+    },
+    user: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    referralCode: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    noOfReferralsUsed: {
+      type: Number,
+      default: 0,
+    },
+    referralCodeUsed: {
+      referralCode: { type: String },
+      date: { type: Date },
+      user: {
+        type: connection.base.Schema.ObjectId,
+        ref: "User",
+      }
+    },
+  }, { timestamps: true });
+
+  return ReferralUsageSchema;
+};

package/modules/picker/schemas/region.js

@@ -0,0 +1,75 @@
+
+const { VEHICLE_TYPES, PAYMENT_METHODS, RIDE_TYPES } = require("../../../constants");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const RegionSchema = new connection.base.Schema({
+    regionName: {
+      type: String,
+    },
+    geoLongLat: {
+      type: {
+        type: String,
+        enum: "Polygon",
+        default: "Polygon",
+      },
+      coordinates: {
+        type: Array,
+      },
+    },
+    isBlocked: {
+      type: Boolean,
+      default: false,
+    },
+    isDeleted: {
+      type: Boolean,
+      default: false,
+    },
+    carType: {
+      type: Number,
+      enum: [
+        VEHICLE_TYPES.BIKE.INDEX,
+        VEHICLE_TYPES.LITE.INDEX,
+        VEHICLE_TYPES.BOTH.INDEX,
+      ],
+      index: true,
+    },
+    paymentType: {
+      type: Number,
+      required: true,
+      enum: [
+        PAYMENT_METHODS.CARD.INDEX,
+        PAYMENT_METHODS.CASH.INDEX,
+        PAYMENT_METHODS.BOTH.INDEX,
+      ],
+    },
+    rideType: {
+      type: Number,
+      required: true,
+      enum: [
+        RIDE_TYPES.NOW.INDEX,
+        RIDE_TYPES.LATER.INDEX,
+        RIDE_TYPES.BOTH.INDEX,
+      ],
+    },
+    superRegionID: {
+      type: connection.base.Schema.ObjectId,
+      ref: "SuperRegion",
+      required: true,
+      index: true,
+    },
+    highDemandThreshold: {
+      type: Number,
+      min: 0,
+    },
+    specialFeesActive: [{
+      type: String,
+      enum: [
+        "RAIN_FEE",
+        "RUSH_HOUR_FEE",
+      ],
+    }],
+  }, { timestamps: true });
+
+  return RegionSchema;
+};

package/modules/picker/schemas/review.js

@@ -0,0 +1,42 @@
+const { CALIFICATION } = require("../../../constants");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const calificationsSchema = new connection.base.Schema({
+    number: {
+      type: Number,
+      required: true,
+      enum: [
+        CALIFICATION.EFFICIENT.text,
+        CALIFICATION.FAST.text,
+        CALIFICATION.INEFFICIENT.text,
+        CALIFICATION.KIND.text,
+        CALIFICATION.LATE.text,
+        CALIFICATION.RUDE.text
+      ]
+    },
+    text: {
+      type: String,
+      required: true,
+      enum: [
+        CALIFICATION.EFFICIENT.text,
+        CALIFICATION.FAST.text,
+        CALIFICATION.INEFFICIENT.text,
+        CALIFICATION.KIND.text,
+        CALIFICATION.LATE.text,
+        CALIFICATION.RUDE.text
+      ]
+    }
+  }, { _id: false });
+  const ReviewSchema = new connection.base.Schema({
+    reviewBy: { type: connection.base.Schema.ObjectId, ref: 'User', required: true },
+    reviewed: { type: connection.base.Schema.ObjectId, ref: 'User', required: true },
+    bookingID: { type: connection.base.Schema.ObjectId, ref: 'Bookings', required: true },
+    bookingNumericId: { type: Number },
+    review: { type: String, default: 'NA' },
+    rating: { type: Number },
+    califications: [calificationsSchema]
+  }, { timestamps: true });
+
+  return ReviewSchema;
+};

package/modules/picker/schemas/session.js

@@ -0,0 +1,25 @@
+const { DEVICE_TYPES } = require("../../../constants").USER;
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const SessionSchema = new connection.base.Schema({
+    user: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+    },
+    remoteIP: { type: String },
+    deviceType: {
+      type: String,
+      enum: [
+        DEVICE_TYPES.IOS,
+        DEVICE_TYPES.ANDROID,
+        DEVICE_TYPES.WEB,
+      ],
+    },
+    deviceToken: {
+      type: String,
+    },
+  }, { timestamps: true });
+
+  return SessionSchema;
+};

package/modules/picker/schemas/superRegion.js

@@ -0,0 +1,41 @@
+
+const { VEHICLE_TYPES } = require("../../../constants");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const RegionSchema = new connection.base.Schema({
+    name: {
+      type: String,
+      required: true,
+    },
+    isActive: {
+      type: Boolean,
+      required: true,
+    },
+    coordinates: {
+      type: {
+        type: String,
+        default: "Point",
+      },
+      coordinates: {
+        type: [Number],
+        default: [0, 0],
+      },
+    },
+    range: {
+      type: Number,
+      required: true,
+    }, // In kms
+    carType: {
+      type: Number,
+      enum: [
+        VEHICLE_TYPES.BIKE.INDEX,
+        VEHICLE_TYPES.LITE.INDEX,
+        VEHICLE_TYPES.BOTH.INDEX,
+      ],
+      index: true,
+    },
+  }, { timestamps: true });
+
+  return RegionSchema;
+};