playov2-js-utilities 0.3.61 → 0.3.62

package/lib/db_interface/monog/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    USER_MODELS: require('./userSchemas/_userIndex.js'),
+    ACTIVITY_MODELS: require('./activitySchemas/_activityIndex.js')
+}

package/lib/db_interface/monog/schemas/activitySchemas/_activityIndex.js

@@ -0,0 +1,5 @@
+module.exports = {
+    userActivity: require('./userActivity.js'),
+    activityInsurance: require('./activityInsurance.js'),
+    activityLocation: require('./activityLocation.js'),
+}

package/lib/db_interface/monog/schemas/activitySchemas/activityInsurance.js

@@ -0,0 +1,17 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var InsuranceSchema = new Schema({
+    isEnabled: { type: Boolean, default: false },
+    insuranceFee: { type: Number, default: 9 },
+    insuranceDefault: {
+        startDate: { type: Date, required: true },
+        endDate: { type: Date, required: true },
+        fee: { type: Number, default: 0 }
+    },
+    insuranceInfo: { type: String, required: true },
+    freeInsuranceInfo: { type: String, required: true },
+    countryCode: { type: String, default: '+91' }
+});
+
+module.exports = mongoose.model('activityInsurance', InsuranceSchema);

package/lib/db_interface/monog/schemas/activitySchemas/activityLocation.js

@@ -0,0 +1,105 @@
+const mongoose = require('mongoose')
+const Schema = mongoose.Schema
+
+const groupSchema = new Schema({
+  _id: false,
+  groupId: String,
+  modTS: Date
+});
+
+const activityLocationSchema = new Schema(
+  {
+    id: { required: true, type: String, unique: true },
+    geoLocation: {
+      type: { type: String },
+      coordinates: [Number],
+    },
+    date: Date,
+    timing: Number,
+    startTime: { type: Date, default: "" },
+    endTime: { type: Date, default: "" },
+    sportId: { required: true, type: String },
+    isOnline: { type: Boolean, default: false },
+    priority: { type: Number, default: 10 },
+    recommended: {type: Boolean, default: false},
+    sponsored: { type: Boolean, default: false },
+    geoHash: { type: String },
+    cityCode: { type: Number },
+    countryCode: { type: String, default: "" },
+    sponsoredRadius: { type: Number, default: null }, // if null, show across city radius or, show to people in spoecified sponsoredRadius
+    full: { type: Boolean, default: false },
+    activityType: { type: String, default: "regular" },
+    hostId: { type: String, required: true },
+    venueId: { default: "", type: String },
+    groupId: { type: String, default: "" },
+    booking: { type: Boolean, default: false },
+    type: { default: 0, type: Number }, // 0 - regular, 1 - pay and join
+    minSkill: { type: Number, default: 1, min: 1, max: 5 },// 1-5
+    maxSkill: { type: Number, default: 5, min: 1, max: 5 }, 
+    hostType: {
+      type: String,
+      enum: ['playo-game', 'regular'],
+      default: 'regular'
+    },
+    joinees: [{
+      _id: false,
+      userId: { type: String, required: true },
+      joineeMsg: { type: String, default: "" },
+      hostMsg: { type: String, default: "" },
+      timestamp: { type: Date, default: Date.now },
+      status: { type: Number, required: true, min: -1, max: 4 }, //-1 to 5  ;-1= Request/Revoke,0-Request Pending,1-Request/Accept,2-Request/Reject,3-Accept/Revoked,4-Invited/Pending,5-Invite/Revoke
+      ticketCount: { type: Number, default: 1 }, // no of tickets booked
+      sentBy: String,
+      rejectedBy: { type: String, default: "" },  // differentiate between host and cohost
+      muteNotifications: { type: Boolean, default: false },
+      amount: { type: Number, default: 0 },
+      refunded: { type: Boolean, default: 0 },
+      acceptTS: { type: Date, default: null }
+    }],
+    strictSkill: { type: Boolean, default: false },
+    sportsPlayingMode: {
+      _id: false,
+      name: { type: String, default: '' },
+      icon: { type: String, default: '' }
+    },
+    cohostId: { type: String, default: '' },
+    maxPlayers: { type: Number, default: -1 },
+    groups: [
+      groupSchema
+    ],
+    location: { type: String, required: true },
+    price: { type: Number, default: 0 },
+    bookingId: {type:String,default:""},
+    bookedBy: {type:String,default:""},//mongoId
+    skillSet: { type: Boolean, default: false },
+    createdTS: { type: Date, default: Date.now },
+    modTS: { type: Date, default: Date.now },
+    venueName: { default: "", type: String },
+    createdBy: { type: Number, default: 0 },// when booking happened app will create activity for that sport with different createdBy value
+    bookingType: { type: Number, default: 0 }, // 0- playo booking, 1-offline
+    courtInfo: { type: String, default: "" },
+    groupName: { type: String, default: "" },
+    currencyTxt: { type: String, default: "" },
+//    activityStack: {type: Boolean},
+  }
+);
+
+module.exports = mongoose.model("activityLocation", activityLocationSchema)
+/*
+
+GeoHash length	Grid Area width x height
+
+1 ≤ 5,000km X 5,000 Km
+2 ≤ 1,250km X 625km
+3 ≤ 156km X 156km
+4	≤ 39.1km X 19.5km
+5	≤ 4.89km X 4.89km
+6	≤ 1.22km X 0.61km
+7	≤ 153m X 153m
+8	≤ 38.2m X 19.1m
+9	≤ 4.77m X 4.77m
+10	≤ 1.19m X 0.596m
+11	≤ 149mm X 149mm
+12	≤ 37.2mm X 18.6mm
+
+ */

package/lib/db_interface/monog/schemas/activitySchemas/activityQueryBlock.js

@@ -0,0 +1,12 @@
+const Mongoose = require("mongoose")
+const Schema = Mongoose.Schema
+
+const activityQueryBlockSchema = new Schema(
+    {
+        userId: { type: String, required: true },
+        expiry: { type: Date, required: true }
+    }
+)
+
+
+module.exports = Mongoose.model("activityQueryBlock", activityQueryBlockSchema)

package/lib/db_interface/monog/schemas/activitySchemas/activityView.js

@@ -0,0 +1,14 @@
+const Mongoose = require("mongoose")
+const Schema = Mongoose.Schema
+
+const activityViewSchema = new Schema(
+    {
+        userId: { type: String, required: true },
+        activityId: { type: String, required: true },
+        count: { type: Number, default: 0 },
+        createdTS: { type: Date, default: Date.now }
+    }
+)
+
+
+module.exports = Mongoose.model("activityView", activityViewSchema)

package/lib/db_interface/monog/schemas/activitySchemas/cronJobLog.js

@@ -0,0 +1,13 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+
+const cronJobLogSchema = new Schema(
+  {
+    id: String,
+    scheduledAt: Date,
+    type: { type: Number, min: 0, max: 1 }, // 0 - make activity past ; 1 - make activity expired
+    modTS: { type: Date, default: Date.now }
+  }
+)
+
+module.exports = MONGOOSE.model("cronjob", cronJobLogSchema)

package/lib/db_interface/monog/schemas/activitySchemas/playogame.request.js

@@ -0,0 +1,38 @@
+const Mongoose = require("mongoose")
+
+const PlayogameRequest = new Mongoose.Schema(
+    {
+        id: {
+            type: String,
+            required: true
+        },
+        userId: {
+            type: String,
+            required: true
+        },
+        areaId: {
+            type: String
+        },
+        sportId: {
+            type: String
+        },
+        venueId: {
+            type: String
+        },
+        createdTS: {
+            type: Date,
+            default: Date.now
+        },
+        message: {
+            type: String
+        },
+        date: {
+            type: Date
+        },
+        timingSlot: [
+            Number
+        ]
+    }
+)
+
+module.exports = Mongoose.model("playogamerequest", PlayogameRequest);

package/lib/db_interface/monog/schemas/activitySchemas/scheduled.tasks.js

@@ -0,0 +1,53 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+// compound index on queueId and taskId and status, so that a task is saved only once per queue
+const scheduledTaskSchema = new Schema({
+    taskId: { type: String, required: true },
+    queueId: { type: String, required: true },
+    ttl: {},
+    payload: {
+
+    },
+    activationTime: {
+        type: Date, required: true
+    },
+    cloudProvider: {
+        type: String,
+        enum: ['GCP', 'AWS'],
+        required: true
+    },
+    status: {
+        type: String,
+        enum: ['saved', 'executed', 'failed', 'cancelled'],
+        default: 'saved',
+        required: true
+    },
+    lastExecutionDetails: {
+
+    }
+});
+
+
+// Modelling explaination - 
+/**
+ * This model acts as an interface to schedule tasks and basically access this code - 
+ * 
+ *         const messagePayload = {
+            httpMethod,
+            url,
+            headers,
+            body,
+            query,
+            oidcToken: {
+                'serviceAccountEmail': TASK_QUEUE_SERVICE_ACCOUNT
+            }
+        };
+
+
+        return Publisher.createHttpTask(queueId, messagePayload, { delay }, taskId, requestId);
+
+        This also requires a compound index on following keys - {queueId, taskId, and status of the saved task}.
+        payload is kept to schemaless so as to accomodate further future changes,
+ */
+module.exports = mongoose.model('scheduledtasks', scheduledTaskSchema);

package/lib/db_interface/monog/schemas/activitySchemas/userActivity.js

@@ -0,0 +1,134 @@
+const mongoose = require('mongoose')
+const Schema = mongoose.Schema
+
+const groupSchema = new Schema({
+  _id: false,
+  groupId: String,
+  modTS: Date
+});
+
+const UserActivitySchema = new Schema({
+  id: { type: String, required: true, unique: true },
+  oldPlayoId: { type: String, default: "" },
+  hostId: { type: String, required: true },
+  sportId: { type: String, required: true },
+  date: { type: Date, required: true },
+  timing: { type: Number, required: true },
+  cohostId: { type: String, default: '' },
+  maxPlayers: { type: Number, default: -1 },
+  cityCode: { type: Number },
+  countryCode: { type: String, default: "" },
+  groups: [
+    groupSchema
+  ],
+  joinees: [{
+    _id: false,
+    userId: { type: String, required: true },
+    joineeMsg: { type: String, default: "" },
+    hostMsg: { type: String, default: "" },
+    timestamp: { type: Date, default: Date.now },
+    status: { type: Number, required: true, min: -1, max: 4 }, //-1 to 5  ;-1= Request/Revoke,0-Request Pending,1-Request/Accept,2-Request/Reject,3-Accept/Revoked,4-Invited/Pending,5-Invite/Revoke
+    ticketCount: { type: Number, default: 1 }, // no of tickets booked
+    sentBy: String,
+    rejectedBy: { type: String, default: "" },  // differentiate between host and cohost
+    muteNotifications: { type: Boolean, default: false },
+    amount: { type: Number, default: 0 },
+    refunded: { type: Boolean, default: 0 },
+    acceptTS: { type: Date, default: null }
+  }],
+  queries: [{
+    _id: false,
+    messageId: String,
+    userId: String,
+    message: String,
+    isAnswered: { type: Boolean, default: false },
+    timestamp: Date,
+    answer: {
+      answerId: String,
+      answer: String,
+      userId: String,
+      timestamp: Date
+    }
+  }],
+  full: { type: Boolean, default: false },
+  geoLocation: {
+    type: { type: String },
+    coordinates: [Number],
+  },
+  location: { type: String, required: true },
+  gameInstructions: { type: String, default: '' },
+  gender: { type: Number, default: 2, min: 0, max: 2 }, //0-female 1-male 2-does not matter
+  price: { type: Number, default: 0 },
+  bookingId: String,
+  bookedBy: String,//mongoId
+  miscInfo: String,
+  shareLink: { type: String, default: "", },
+  deferLink: { type: String, default: "" },
+  fullLink: { type: String, default: "" },
+  startTime: { type: Date, default: null }, // hh:mm:ss
+  endTime: { type: Date, default: null }, //hh:mm:ss
+  isListed: { type: Boolean, default: true }, // 0-unlisted, 1-listed
+  minSkill: { type: Number, default: 1, min: 1, max: 5 },// 1-5
+  maxSkill: { type: Number, default: 5, min: 1, max: 5 }, // 1-5
+  skillSet: { type: Boolean, default: false },
+  booking: { type: Boolean, default: false },
+  type: { default: 0, type: Number }, // 0 - regular, 1 - pay and join
+  cancelled: { type: Boolean, default: false },
+  past: { type: Boolean, default: false },
+  createdTS: { type: Date, default: Date.now },
+  modTS: { type: Date, default: Date.now },
+  tags: [],
+  venueId: { default: "", type: String },
+  // groupModTS: { type: String, default: Date.now },
+  venueName: { default: "", type: String },
+  hostLastVisit: Date,
+  cohostLastVisit: Date,
+  createdBy: { type: Number, default: 0 },// when booking happened app will create activity for that sport with different createdBy value
+  bookingType: { type: Number, default: 0 }, // 0- playo booking, 1-offline
+  courtInfo: { type: String, default: "" },
+  bookedOn: { type: Date },
+  expired: { type: Boolean, default: false },
+  timeString: String, //For playo-v1 support,
+  notifiedBy: { type: Array, default: [] },
+  activityType: { type: String, default: "regular" }, // accepted values are regular,coaching,tournament
+  isOnline: { type: Boolean, default: false },
+  views: { type: Number, default: 0 },
+  groupId: { type: String, default: "" },
+  groupName: { type: String, default: "" },
+  superUser: { type: Boolean, default: false },
+  priority: { type: Number, default: 10 },
+  muteNotifications: { type: Boolean, default: false },
+  currencyTxt: { type: String, default: "" },
+  activityStack: Boolean,
+  sponsored: { type: Boolean, default: false },
+  joineeRules: [String],
+  strictSkill: { type: Boolean, default: false },
+  sportsPlayingMode: {
+    _id: false,
+    name: { type: String, default: '' },
+    icon: { type: String, default: '' }
+  },
+  addons: [{
+    _id: false,
+    userId: { type: String, required: true },
+    insurance: { type: Boolean, required: true }
+  }],
+  hostType: {
+    type: String,
+    enum: ['playo-game', 'regular'],
+    default: 'regular'
+  },
+  partialPayable: { type: Boolean, default: false },
+  payableAtVenue: { type: Number, default: 0 }
+  
+})
+
+// UserActivitySchema.index({ "geoLocation": "2dsphere" })
+// UserActivitySchema.index({ 'hostId': 1 })
+// UserActivitySchema.index({ 'date': 1 }, { 'background': true })
+// UserActivitySchema.index({ 'sportId': 1 })
+// UserActivitySchema.index({ 'modTS': 1 }, { 'background': true })
+// UserActivitySchema.index({ 'joinees.userId': 1, 'joinee.status': 1 }, { 'background': true })
+// UserActivitySchema.index({ "groups.groupId": 1 }, { "background": true })
+
+module.exports = mongoose.model('UserActivity', UserActivitySchema)

package/lib/db_interface/monog/schemas/userSchemas/QuickActions.js

@@ -0,0 +1,26 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const quickActionsSchema = new Schema(
+    {
+        actionDismissed: Boolean,
+        actionType: { type: String, default: "common" },
+        actionParameterId: String, //--> activity Id or relevant id 
+        userId: String,
+        id: String, //--> cumulative data of (actionId + actionType ) => actionType_actionId
+        expired: { type: Boolean, default: false },
+        palIds: [{
+            type: String,
+            default: []
+        }]
+    },
+    { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } }
+)
+
+quickActionsSchema.index({ userId: 1 });
+quickActionsSchema.index({ ActionId: 1 });
+quickActionsSchema.index({id: 1});
+
+const QuickActions = mongoose.model('QuickActions', quickActionsSchema);
+
+module.exports = QuickActions;

package/lib/db_interface/monog/schemas/userSchemas/_userIndex.js

@@ -0,0 +1,8 @@
+module.exports = {
+    user: require('./user.js'),
+    userFavorite: require("./userFavourites.js"),
+    sports: require("./sports.js"),
+    cities: require("./city.js"),
+    blockedUsers: require("./blockedUser.js"),
+    userReputation: require("./userReputation.js"), 
+} 

package/lib/db_interface/monog/schemas/userSchemas/blockedUser.js

@@ -0,0 +1,12 @@
+const mongoose = require('mongoose')
+const Schema = mongoose.Schema
+const blockedUserSchema = new Schema({
+  email: { type: String, primary: true, default: "" },
+  mobile: { type: String, default: "" },
+  createdTS: { type: Date, default: new Date().toISOString() },
+  remarks: { type: String, default: "" },
+})
+const blockedUser = mongoose.model('BlockedUser', blockedUserSchema)
+
+
+module.exports = blockedUser

package/lib/db_interface/monog/schemas/userSchemas/city.js

@@ -0,0 +1,62 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var CitySchema = new Schema({
+  name: { type: String, required: true },
+  cityCode: { type: Number, required: true },
+  karmaCredit: {},
+  countryCode: { type: String, required: true },
+  curCode: { type: String, default: '' },
+  sports: String,
+  countryId: { type: String, default: "" },
+  currencyTxt: { type: String },
+  absKarma: Number,
+  isKarmaPercent: Boolean,
+  karmaPercent: Number,
+  karmaRatio: Number,
+  karmaOnRefer: Number,
+  karmaEnabled: { type: Boolean, default: true },
+  karmaForInvitee: Number,
+  radius: Number,
+  geoLocation: {
+    type: { type: String },
+    coordinates: []
+  },
+  timeZone: { type: String, default: "" },
+  minOffset: { type: Number, default: -330 },
+  countryBound: {
+  },
+  phoneLength: Number,
+  helpline: String,
+  helpType: { type: Number, default: 0 }, //0 - Call, 1 - Mail
+  countryName: String,
+  areaRadius: { type: Number, default: 3 },
+  faqUrl: { type: String, default: "" },
+  bulkBooking: { type: Boolean, default: false },
+  isreviewed: { type: Boolean },
+  notificationPref: [
+    {
+      category: String,
+      status: Boolean
+    }
+  ],
+  placeId: { type: String, required: true },
+  userFields : [{
+    _id : false,
+    id: { type: String, required: true },
+    name: { type: String, required: true },
+    type: { type: String, required: true },
+    format: { type: String, required: true },
+    mandatoryHosting: { type: Boolean, required: true },
+    mandatoryPayment: { type: Boolean, required: true },
+    mandatoryOffline: { type: Boolean, required: true },
+    priority: { type: Number, required: true },
+    venueSpecific: { type: Boolean, default: false },
+    unique: { type: Boolean, default: false },
+    render: { type: Boolean, default: true }
+  }]
+}, { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } });
+
+CitySchema.index({ 'geoLocation': "2dsphere" })
+
+module.exports = mongoose.model('City', CitySchema);

package/lib/db_interface/monog/schemas/userSchemas/country.js

@@ -0,0 +1,64 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+
+
+
+const countrySchema = new Schema(
+  {
+
+    karmaDebit: {
+      isKarmaPercent: Boolean,
+      karmaPercent: Number,
+      karmaRatio: Number,
+      absKarma: Number,
+    },
+    karmaCredit: {},
+    timeZone: { type: String, default: "" },
+    timeZoneName: String,
+    countryCode: { type: String, required: true },
+    countryId: { type: String, default: "" },
+    countryAlpha3Code: { type : String, default: ""},
+    currencyTxt: { type: String },
+    curCode: { type: String, default: "" },
+    name: { type: String, required: true },
+    language: { type: String, default: "" },
+    helpType: { type: Number, default: 0 },
+    radius: { type: Number, default: 3 },
+    areaRadius: Number,
+    helpLine: String,
+    geoLocation: {
+      type: { type: String }, // type: multipolygon
+      coordinates: []
+    },
+    countryBound: {
+    },
+    rawOffset: { type: Number, default: 0 },
+    dstOffset: { type: Number, default: 0 },
+    faqUrl: { type: String, default: "https://playo.co/support/" },
+    bulkBooking : { type: Boolean, default: false },
+    notificationPref : [
+      {
+        category: String,
+        status: Boolean
+      }
+    ],
+    userFields : [{
+      _id : false,
+      id: {type: String, required: true },
+      name: { type: String, required: true },
+      type: { type: String, required: true },
+      format: { type: String, required: true },
+      mandatoryHosting: { type: Boolean, required: true },
+      mandatoryPayment: { type: Boolean, required: true },
+      mandatoryOffline: { type: Boolean, required: true },
+      priority: { type: Number, required: true },
+      venueSpecific: {type: Boolean, default: false },
+      unique: { type: Boolean, default: false },
+      render: { type: Boolean, default: true }
+    }]
+  }
+)
+
+countrySchema.index({ 'geoLocation': "2dsphere" })
+
+module.exports = MONGOOSE.model("country", countrySchema)

package/lib/db_interface/monog/schemas/userSchemas/emailOtp.js

@@ -0,0 +1,13 @@
+var mongoose = require('mongoose');
+const Moment = require("moment")
+var Schema = mongoose.Schema;
+
+var EmailOtoSchema = new Schema({
+  email: { type: String, required: true, unique: true },
+  ts: { type: String, default: Moment().add(4,"hours") },
+  otp: { type: Number, required: true }
+},{timestamps:{createdAt:"createdTS",updatedAt:"modTS"}});
+
+
+
+module.exports = mongoose.model('emailotp', EmailOtoSchema);

package/lib/db_interface/monog/schemas/userSchemas/emailVerificationToken.js

@@ -0,0 +1,12 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+
+const emailVerificationToken = new Schema(
+  {
+    userId: { type: String, required: true, unique: true },
+    token: String,
+    expiry: Date
+  }
+  , { timestamps: { createdAt: "createdTS", updatedAt: "modTS" } })
+
+module.exports = MONGOOSE.model("emailverificationtoken", emailVerificationToken)

package/lib/db_interface/monog/schemas/userSchemas/gt.trial.games.js

@@ -0,0 +1,24 @@
+const mongoose = require("mongoose");
+const Schema = mongoose.Schema;
+const gtTrialGamesSchema = new Schema(
+  {
+    userId: { type: String, required: true },
+    activityId: { type: String, required: true },
+    status: {
+      type: String,
+      required: true,
+      default: "pending",
+      enum: ["pending", "completed", "cancelled"],
+    },
+    venueId: { type: String, required: true },
+    discountPercentageAvailed: {
+      type: Number,
+      min: 0,
+      max: 100
+    }
+  },
+  { timestamps: { createdAt: "createdTS", updatedAt: "modTS" } }
+);
+const gtTrialGames = mongoose.model("gtTrialGames", gtTrialGamesSchema);
+
+module.exports = gtTrialGames;

package/lib/db_interface/monog/schemas/userSchemas/invite.js

@@ -0,0 +1,14 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var InviteSchema = new Schema({
+  userId: { type: String, required: true },
+  invites: [{
+    _id: false,
+    invitee: { type: String, required: true },
+    modTS: { type: Date, default: Date.now },
+    tag: String
+  }]
+});
+
+module.exports = mongoose.model('Invite', InviteSchema);

package/lib/db_interface/monog/schemas/userSchemas/karmaConfig.js

@@ -0,0 +1,12 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+
+const karmaConfigSchema = new Schema(
+  {
+    id: { type: String, default: "" },
+    karma: { type: Number, default: 0 },
+    remarks: { type: String, default: "" }
+  }
+)
+
+module.exports = MONGOOSE.model("karmaconfig", karmaConfigSchema)