picker-db 3.4.0

package/modules/picker/index.js

@@ -0,0 +1,259 @@
+const dbModels = require("./models");
+const Mongo = require("../../lib/Mongo");
+
+/**
+ * Class representing a connection to Picker's mongoDB database
+ */
+class PickerMongoDBService {
+  /**
+   * Initializes a connection to the selected database
+   * @param {object} config
+   */
+  constructor (config = {}) {
+    this.connection = new Mongo(config);
+  }
+
+  /**
+   * Connects to the database and loads all PickerMongoDB models
+   */
+  async connect () {
+    const connection = await this.connection.getConnection();
+    this.models = dbModels(connection);
+  }
+
+  async disconnect () {
+    this.connection.disconnect();
+  }
+
+  /**
+   * Wrapper around 'save' method
+   * @description Inserts a document in the database
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} objToSave Document information to save
+   * @returns {Promise<object[]>}
+   */
+  async createData (modelName, objToSave) {
+    return new Promise((resolve, reject) => {
+      const data = new this.models[modelName](objToSave);
+      data.save(objToSave, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'find' method
+   * @description Returns all documents that match the query
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @param {object} projection Model's field to return from this query
+   * @param {object} options Query options
+   * @returns {Promise<object[]>}
+   */
+  async getDataAsync (modelName, criteria = {}, projection = {}, options = {}) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].find(criteria, projection, options, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'find' method with 'populate'
+   * @description Returns all documents that match the query with the populated fields
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @param {object} projection Model's field to return from this query
+   * @param {object} options Query options
+   * @param {*} populateModel
+   * @returns {Promise<object[]>}
+   */
+  async getDataPopulateAsync (modelName, criteria, projection, options, populateModel) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].find(criteria, projection, options).populate(populateModel).exec((err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'findOne' method
+   * @description Returns the first document that matches the query
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @param {object} projection Model's field to return from this query
+   * @param {object} options Query options
+   * @returns {Promise<object>}
+   */
+  async getFirstMatch (modelName, criteria, projection, options) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].findOne(criteria, projection, options, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'findOne' method with 'populate'
+   * @description Returns the first document that matches the query with the populated fields
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @param {object} projection Model's field to return from this query
+   * @param {object} options Query options
+   * @param {*} populateModel
+   * @returns {Promise<object>}
+   */
+  async getFirstMatchPopulate (modelName, criteria, projection, options, populateModel) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].findOne(criteria, projection, options).populate(populateModel).exec((err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'findOneAndUpdate' method
+   * @description Updates the first document that matches the query
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @param {object} dataToSet Update to execute
+   * @param {object} options Query options
+   * @returns {Promise<object>}
+   */
+  async updateData (modelName, criteria, dataToSet, options) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].findOneAndUpdate(criteria, dataToSet, options, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'update' method
+   * @description Updates all the documents that match the query
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @param {object} dataToSet Update to execute
+   * @param {object} options Query options
+   * @returns {Promise<object>}
+   */
+  async updateMultiple (modelName, criteria, dataToSet, options = {}) {
+    options.multi = true;
+    return new Promise((resolve, reject) => {
+      this.models[modelName].update(criteria, dataToSet, options, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'findOneAndRemove' method
+   * @description Deletes the first document that matches the query
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @returns {Promise<object[]>}
+   */
+  async deleteData (modelName, criteria) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].findOneAndRemove(criteria, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'deleteMany' method
+   * @description Deletes all the documents that match the query
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @returns {Promise<object[]>}
+   */
+  async deleteMany (modelName, criteria) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].deleteMany(criteria, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'count' method
+   * @description Counts all the documents that match the query
+   * @param {string} modelName Name of the model for this operation
+   * @param {object} criteria Query
+   * @returns {Promise<object[]>}
+   */
+  async countData (modelName, criteria) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].count(criteria, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'aggregate' method
+   * @param {string} modelName Name of the model for this operation
+   * @param {object[]} pipeline
+   * @returns {Promise<object[]>}
+   */
+  async aggregateData (modelName, pipeline) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].aggregate(pipeline).exec((err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Wrapper around 'aggregate' method using a cursor
+   * @param {string} modelName Name of the model for this operation
+   * @param {object[]} pipeline
+   * @returns {Promise<object[]>}
+   */
+  async aggregateDataCursor (modelName, pipeline) {
+    return new Promise((resolve, reject) => {
+      this.models[modelName].aggregate(pipeline).allowDiskUse(true).cursor({ batchSize: 2000 }).exec((err, res) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(res);
+      });
+    });
+  }
+}
+
+module.exports = PickerMongoDBService;

package/modules/picker/models/identityCounter.js

@@ -0,0 +1,15 @@
+const schema = require("../schemas/identityCounter");
+
+let model;
+
+const getModel = (connection) => {
+  if (model) {
+    return model;
+  }
+  model = connection.model("IdentityCounter", schema(connection));
+  return model;
+};
+
+module.exports = {
+  getModel,
+};

package/modules/picker/models/index.js

@@ -0,0 +1,50 @@
+const UserSchema = require("../schemas/user");
+const CustomerSchema = require("../schemas/customer");
+const DriverSchema = require("../schemas/driver");
+const BusinessSchema = require("../schemas/business");
+const BookingSchema = require("../schemas/bookings");
+const SessionSchema = require("../schemas/session");
+const NotificationSchema = require("../schemas/notification");
+const BusinessCategorySchema = require("../schemas/businessCategory");
+const BalanceTransactionSchema = require("../schemas/balanceTransaction");
+const FareSettingSchema = require("../schemas/fareSettings");
+const RegionSchema = require("../schemas/region");
+const SuperRegionSchema = require("../schemas/superRegion");
+const AddressSchema = require("../schemas/address");
+const MassDeliverySchema = require("../schemas/massDelivery");
+const BillSchema = require("../schemas/bill");
+const FraudBookingSchema = require("../schemas/fraudBooking");
+const AdminSettingSchema = require("../schemas/adminSetting");
+const PaymentezTransactionSchema = require("../schemas/paymentezTransaction");
+const PaymentezCustomerSchema = require("../schemas/paymentezCustomer");
+const PreferenceSchema = require("../schemas/preference");
+const ReferralUsageSchema = require("../schemas/referralUsage");
+const ReviewSchema = require("../schemas/review");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  return {
+    Bookings: connection.model("Bookings", BookingSchema(connection)),
+    User: connection.model("User", UserSchema(connection)),
+    Business: connection.model("Business", BusinessSchema(connection)),
+    Driver: connection.model("Driver", DriverSchema(connection)),
+    Customer: connection.model("Customer", CustomerSchema(connection)),
+    Session: connection.model("Session", SessionSchema(connection)),
+    Notification: connection.model("Notification", NotificationSchema(connection)),
+    BusinessCategory: connection.model("BusinessCategory", BusinessCategorySchema(connection)),
+    BalanceTransaction: connection.model("BalanceTransaction", BalanceTransactionSchema(connection)),
+    Fares: connection.model("Fares", FareSettingSchema(connection)),
+    SuperRegion: connection.model("SuperRegion", SuperRegionSchema(connection)),
+    Region: connection.model("Region", RegionSchema(connection)),
+    Address: connection.model("Address", AddressSchema(connection)),
+    MassDelivery: connection.model("MassDelivery", MassDeliverySchema(connection)),
+    Bill: connection.model("Bill", BillSchema(connection)),
+    FraudBooking: connection.model("FraudBooking", FraudBookingSchema(connection)),
+    AdminSetting: connection.model("AdminSetting", AdminSettingSchema(connection)),
+    PaymentezTransaction: connection.model("PaymentezTransaction", PaymentezTransactionSchema(connection)),
+    PaymentezCustomer: connection.model("PaymentezCustomer", PaymentezCustomerSchema(connection)),
+    Preference: connection.model("Preference", PreferenceSchema(connection)),
+    ReferralUsage: connection.model("ReferralUsage", ReferralUsageSchema(connection)),
+    Review: connection.model("Review", ReviewSchema(connection)),
+  };
+};

package/modules/picker/schemas/address.js

@@ -0,0 +1,74 @@
+const { ADDRESS_TYPES } = require("../../../constants");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const AddressSchema = new connection.base.Schema({
+    companyName: {
+      type: String,
+    },
+    companyAddress: {
+      type: String,
+    },
+    latitude: {
+      type: Number,
+      default: null,
+    },
+    longitude: {
+      type: Number,
+      default: null,
+    },
+    city: {
+      type: String,
+      default: null,
+    },
+    state: {
+      type: String,
+      default: null,
+    },
+    zipCode: {
+      type: String,
+      default: null,
+    },
+    addressType: {
+      type: String,
+      enum: [
+        ADDRESS_TYPES.SELF,
+        ADDRESS_TYPES.DELIVERY,
+        ADDRESS_TYPES.PICKUP,
+      ],
+    },
+    type: {
+      type: String,
+      enum: [
+        ADDRESS_TYPES.HOME,
+        ADDRESS_TYPES.OFFICE,
+        ADDRESS_TYPES.OTHERS,
+      ],
+      default: ADDRESS_TYPES.HOME,
+    },
+    // For booking pick and delivery addresses only
+    customerID: {
+      type: connection.base.Schema.ObjectId,
+      ref: "Customer",
+      default: null,
+    },
+    isValidAddress: {
+      type: Number,
+      default: 1,
+    },
+    placeID: {
+      type: String,
+      default: null,
+    },
+    title: {
+      type: String,
+      default: null,
+    },
+    fullAddress: {
+      type: String,
+      default: null,
+    },
+  }, { timestamps: true });
+
+  return AddressSchema;
+};

package/modules/picker/schemas/adminSetting.js

@@ -0,0 +1,125 @@
+
+const { PAYMENT } = require("../../../constants").DRIVER;
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const RegionSchema = new connection.base.Schema({
+    otpExpiresIn: {
+      type: Number,
+      default: 300,
+    },
+    linkExpiresIn: {
+      type: Number,
+      default: 300,
+    },
+    deleteTrackingData: {
+      type: Number,
+      default: 1,
+    },
+    webMultiSession: {
+      type: Boolean,
+      default: true,
+    },
+    deviceMultiSession: {
+      type: Boolean,
+      default: false,
+    },
+    adminTokenExpireTime: {
+      type: Number,
+      default: 30,
+    },
+    userTokenExpireTime: {
+      type: Number,
+      default: 43200,
+    },
+    referralSchemeType: {
+      type: String,
+    },
+    isSpecial: {
+      type: Boolean,
+      default: true,
+    },
+    distanceToDelivery: {
+      type: Boolean,
+      default: 200,
+    }, // In meters,
+    minBatteryPercentage: {
+      type: Number,
+      default: 30,
+    }, // Indicates the minimum percentage by which a picker may accept a booking request
+    pickerCommission: {
+      type: Number,
+      default: 40,
+    }, // From the totalFee, over the minimum promised, the percentage corresponded to the picker
+    minDeviceTokenFlag: {
+      type: Number,
+      default: 2,
+    }, // Number of users with the same deviceToken to raise a flag
+    payment: {
+      type: {
+        type: String,
+        enum: [
+          PAYMENT.PERCENTAGE,
+          PAYMENT.ABSOLUTE,
+          PAYMENT.OVER_MINIMUM,
+        ],
+        default: PAYMENT.ABSOLUTE,
+      },
+      value: {
+        type: Number,
+        default: 4,
+      },
+    },
+    searchExpirationTimeMP: {
+      type: Number,
+    }, // Expiration time of the driver search in MP
+    avgPickupTimeMinutes: {
+      type: Number,
+    },
+    timeIntervals: [{
+      text: { type: String },
+      value: { type: Number },
+      index: { type: Number },
+    }],
+    averagePointATime: {
+      type: Number,
+      default: 20,
+    }, // In minutes
+    cancellationTime: {
+      type: Number,
+      min: 0,
+      default: 180, // 180 seconds = 3 minutes
+    }, // In seconds
+    availableDriverCancellation: {
+      type: Boolean,
+      default: false,
+    },
+    addCardLinkExpiresIn: {
+      type: Number,
+      default: 300,
+    },
+    maxDeliveryDistanceMKT: {
+      type: Number,
+      default: 10,
+    }, // In kms
+    shopOrderRequestPercentage: {
+      type: Number,
+      default: 15,
+    }, // In percentage %
+    kmRangeCommissionFee: [{
+      min: { type: Number },
+      max: { type: Number },
+      commission: { type: Number },
+    }],
+    driverExtraCommission: {
+      type: Number,
+      default: 0,
+    }, // Extra commission to charge the picker after a completed booking
+    highDemandThreshold: {
+      type: Number,
+      min: 0,
+    },
+  }, { timestamps: true });
+
+  return RegionSchema;
+};

package/modules/picker/schemas/balanceTransaction.js

@@ -0,0 +1,132 @@
+const _ = require("lodash");
+
+const { PAYMENT_METHODS } = require("../../../constants");
+const { TYPE, STATUS, SELECTED_REASONS } = require("../../../constants").TRANSACTION;
+
+const { getModel } = require("../models/identityCounter");
+
+/** @param {import("mongoose")} connection */
+module.exports = (connection) => {
+  const IdentityCounterModel = getModel(connection);
+
+  const BalanceTransactionSchema = new connection.base.Schema({
+    transactionID: {
+      type: Number,
+      index: true,
+    },
+    type: {
+      type: String,
+      enum: _.values(TYPE),
+      required: true,
+    },
+    amount: {
+      type: Number,
+      required: true,
+    },
+    driver: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    business: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    description: {
+      type: String,
+    },
+    date: {
+      type: Date,
+      required: true,
+    },
+    bookingID: {
+      type: connection.base.Schema.ObjectId,
+      ref: "Bookings",
+      default: null,
+    },
+    paymentMethod: {
+      type: String,
+      enum: [
+        PAYMENT_METHODS.CARD.INDEX,
+        PAYMENT_METHODS.CASH.INDEX,
+        PAYMENT_METHODS.BILLING_CARD.INDEX,
+        PAYMENT_METHODS.BILLING_TRANSFER.INDEX,
+      ],
+      default: PAYMENT_METHODS.NONE,
+    },
+    status: {
+      type: String,
+      enum: _.values(STATUS),
+      default: STATUS.REALIZED,
+    },
+    registeredBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    approvedBy: {
+      type: connection.base.Schema.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    linkedTo: [{
+      balanceTransaction: {
+        type: connection.base.Schema.ObjectId,
+        ref: "BalanceTransaction",
+      },
+      idToShow: {
+        type: String,
+      },
+    }],
+    isLinked: {
+      type: Boolean,
+      default: false,
+    }, // Shows if this transaction has already been linked by a DEPOSIT. Only valid for ITEM transactions
+    bankTransactionID: {
+      type: String,
+    }, // The transactionID from the deposit made
+    bankName: {
+      type: String,
+    },
+    authCode: {
+      type: String,
+    },
+    corporateID: {
+      type: String,
+    },
+    selectedReason: {
+      type: String,
+      enum: _.values(SELECTED_REASONS),
+    },
+    rechargeImage: {
+      thumbnail: {
+        type: String,
+        default: null,
+      },
+      original: {
+        type: String,
+        default: null,
+      },
+    },
+  }, { timestamps: true });
+
+  BalanceTransactionSchema.pre("save", function (next) {
+    if (!this.isNew) {
+      return next();
+    }
+    const doc = this;
+    const query = { model: "BalanceTransaction" };
+    const update = { $inc: { count: 1 } };
+    const options = { new: true };
+    IdentityCounterModel.findOneAndUpdate(query, update, options, function (error, counter) {
+      if (error) {
+        return next(error);
+      }
+      doc.transactionID = counter.count;
+      next();
+    });
+  });
+
+  return BalanceTransactionSchema;
+};