playov2-js-utilities 0.3.61 → 0.3.62

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

@@ -0,0 +1,29 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+const karmaLogSchema = new Schema({
+    userId: String,
+    karma: Number,
+    createdTS: { type: Date, default: Date.now },
+    type: String,
+    remarks: String,
+    id: String
+}, { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } })
+
+karmaLogSchema.index({ 'userId': 1, 'id': 1 })
+
+module.exports = MONGOOSE.model("karmalog", karmaLogSchema)
+
+/**
+  type={
+   activity: on finishing a match successfully
+   firstActivity: on hosting first match successfully
+   venue: on rating avenue
+   referral: on successfull referral
+   profile: on succesfully completing the profile
+   onboard: on on boarding into app,
+   host: karma for successfully hosting activity ,
+   reset: on resetting account,
+   custom: any custom karma
+  }
+  
+ */

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

@@ -0,0 +1,12 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+
+const passwordResetToken = new Schema(
+  {
+    userId: { type: String, required: true, unique : true },
+    token: String,
+    expiry: Date
+  }
+)
+
+module.exports = MONGOOSE.model("passwordresettoken", passwordResetToken)

package/lib/db_interface/monog/schemas/userSchemas/playo.subscription.pack.js

@@ -0,0 +1,67 @@
+const mongoose = require("mongoose");
+const MongooseUtils = require("../mongoose.utils");
+
+const PlayoSubscriptionSchema = new mongoose.Schema(
+  {
+    id: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    name: {
+      type: String,
+      required: true,
+    },
+    cityCode: {
+      type: String,
+      required: true,
+    },
+    sportId: {
+      type: String,
+      required: true,
+    },
+    price: {
+      type: Number,
+      required: true,
+    },
+    strikeThroughPrice: {
+      type: Number,
+      required: true
+    },
+    currencyText: {
+      type: String,
+      default: "INR",
+    },
+    slotsCount: {
+      type: Number,
+      required: true
+    },
+    active: {
+      type: Boolean,
+      default: true,
+    },
+    colorCode: {
+      type: String,
+      required: true
+    },
+    icon: {
+      type: String,
+    },
+    daysValid: {
+      type: Number,
+    },
+    valueSavedPerGame: {
+      type: Number,
+    },
+    maxActiveSubscriptions: {
+      type: Number
+    },
+    countryCode: {
+      type: String,
+      default: '+91'
+    }
+  },
+  MongooseUtils.defaultSchemaOptions
+);
+
+module.exports = mongoose.model("playosubscriptions", PlayoSubscriptionSchema);

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

@@ -0,0 +1,17 @@
+const Mongoose = require("mongoose")
+const Schema = Mongoose.Schema
+
+const rankingsSchema = new Schema(
+    {
+        userId: { required: true, type: String },
+        activityRank: { type: Number, default: 0 },
+        matches: Number,
+        sports: [{
+            sportId: String,
+            rank: Number,
+            matches: Number
+        }]
+    }
+)
+
+module.exports = Mongoose.model("rankings", rankingsSchema)

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

@@ -0,0 +1,26 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var SportsSchema = new Schema({
+	name: { type: String, required: true },
+	sportId: { type: String, required: true, unique: true },
+	isRateable: { type: Number, default: 1 },
+	skillSet: [{
+		skill: String
+	}],
+	grayIcon: String,
+	colorIcon: String,
+	v2GrayIcon: String,
+	v2SportIllustration: String,
+	sportsBro: [],
+	active: { type: Boolean, default: true },
+	content: { type: Boolean, default: false },
+	sportsPlayingMode: [{
+		name: { type: String },
+		icon: { type: String }
+	}],
+	createdTS: { type: Date, default: Date.now },
+	modTS: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('Sports', SportsSchema);

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

@@ -0,0 +1,12 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var SportsCategorySchema = new Schema({
+    id: String,
+    name: String,
+    priority: Number,
+    sports: String,
+    cityCode: Number,
+});
+
+module.exports = mongoose.model('SportsCategory', SportsCategorySchema);

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

@@ -0,0 +1,36 @@
+const { Schema, model } = require('mongoose');
+
+const TempUserSchema = new Schema({
+    id: { type: String, required: true },
+    deviceType: {
+        type: Number,
+        enum: [11, 0, 1], // 1 -> android, 11 -> ios, 0 -> web (not used) 
+        default: -1
+    },
+    onesignalId: [{ type: String }], // onesignalId
+    fcmId: { type: String }, // unique id for devices
+    version: { type: String, default: '' },
+    ispCarrier: { type: String, default: '' },
+    geoLocation: {
+        type: { type: String, default: 'Point' },
+        coordinates: { type: [Number], default: [0, 0] }
+    },
+    geoLocationCity: {
+        type: { type: String, default: 'Point' },
+        coordinates: { type: [Number], default: [0, 0] }
+    },
+    lastActiveAreaName: { type: String, default: '' },
+    cityCode: { type: Number, default: 0 },
+    placeId: { type: String, default: '' },
+    countryCode: { type: String, default: '' },
+    phoneCountryCode: { type: String, default: '' },
+    deviceModel: { type: String, default: '' },
+    versionCode: { type: Number, default: 0 },
+    userRegistered : { type: Boolean, default: false },
+},
+    {
+        timestamps: { createdAt: 'createdTS', updatedAt: "modTS" }
+    }
+);
+
+module.exports = model('TempUser', TempUserSchema);

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

@@ -0,0 +1,14 @@
+const { Schema, model } = require('mongoose');
+
+const TrendingSportsSchema = new Schema({
+    sportId: { type: String, required: true },
+    isTrending: { type: Boolean, required: true },
+    tags: {
+        type: [
+            { type: String }
+        ],
+        default: []
+    }
+})
+
+module.exports = model('TrendingSports', TrendingSportsSchema);

package/lib/db_interface/monog/schemas/userSchemas/user.activity.health.kit.data.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+const MongooseUtils = require('../mongoose.utils');
+
+const userHealthKitSchema = new Schema({
+    userId: { type: String, required: true },
+    activityId: { type: String, required: true },
+    healthKitActivityDate: { type: Date, default: Date.now },
+    peakHeartrateReached: { type: Number, default: 0 },
+    stepsTaken: { type: Number, default: 0 },
+    kCaloriesBurned: { type: Number, default: 0 },
+    minutesPlayed: { type: Number, default: 0 },
+    distanceCoveredInMetres: { type: Number, default: 0 },
+    healthKitDataSource: { type: String, required: true }, // google / ios
+    year: { type: Number, required: true },
+    week: { type: Number, required: true },
+    sportId: { type: String, required: true },
+    metadata: {},
+    isValid: { type: Boolean, default: true },
+    lastSyncedDate: { type: Date, default: null },
+}, MongooseUtils.defaultSchemaOptions);
+
+// compound indexes on - userId and healthKitActivityDate
+// userId, activityId
+
+
+module.exports = mongoose.model('userhealthkitdata', userHealthKitSchema);

package/lib/db_interface/monog/schemas/userSchemas/user.contacts.js

@@ -0,0 +1,34 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+const MongooseUtils = require('../mongoose.utils');
+
+const userContactsSchema = new Schema({
+    id: String,
+    userId: String,
+    fName: String,
+    lName: String,
+    email: String,
+    mobile: {
+        countryCode: String,
+        phone: String
+    },
+    playPal: {
+        type: Boolean,
+        default: false
+    },
+    contactId: {
+        type: String,
+        default: null
+    },
+    active: {
+        type: Boolean,
+        default: true
+    },
+    linkingId: String
+}, MongooseUtils.defaultSchemaOptions);
+
+userContactsSchema.virtual('onPlayo').get(function () {
+    return this.contactId !== null;
+});
+
+module.exports = mongoose.model('UserContacts', userContactsSchema);

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

@@ -0,0 +1,111 @@
+const mongoose = require('mongoose')
+const Schema = mongoose.Schema
+const userSchema = new Schema({
+  id: { type: String, required: true, unique: true },
+  fName: { type: String, default: "" },
+  lName: { type: String, default: "" },
+  userName: {type: String, default: ""},
+  email: { type: String, primary: true, default: "" },
+  officialEmail: { type: String, required: false },
+  mobile: { type: String, default: "" },
+  oldPlayoId: { type: String, default: "" },
+  lastActiveAreaName: { type: String, default: "" },
+  active: { type: Date, default: Date.now },
+  phoneCountryCode: { type: String, default: "" },
+  countryCode: { type: String, default: "" },
+  cityCode: { type: Number, default: 1 },
+  profilePicUrl: { type: String, default: "" },
+  gender: { type: Number, default: 2, min: 0, max: 3 },  // 0-female , 1-male, 2-does not matter;3-others
+  karma: { type: Number, default: 0 },
+  karmaRedeem: { type: Number, default: 0 },
+  city: { type: String, default: "" },
+  geoLocation: {
+    type: { type: String, enum: ['Point'], default: 'Point' },
+    coordinates: {
+      type : [Number], default: [0, 0]
+    }
+  },
+  geoLocationCity: {
+    type: { type: String },
+    coordinates: []
+  },
+  bio: { type: String, default: "" },
+  palsCount: Number,
+  emailVerified: { type: Boolean, default: false },
+  officialEmailVerified: { type: Boolean, default: false },
+  verified: { type: Boolean, default: false },
+  reportCount: Number,
+  superUser: { type: Boolean, default: false },
+  venueId: { type: String, default: "" },
+  rules: { type: String, default: "" },
+  messages: [                        // for notifications
+    {
+      key: String,
+      value: String
+    }
+  ],
+  isOnApplozic: { type: Boolean, default: false },
+  lastPlayed: { type: Date, default: null },
+  // createdTS: { type: Date, default: Date.now },
+  // modTS: {
+  //   type: Date, default: new Date().toISOString(),
+
+  // },
+  helpTS: { type: Date, default: Date.now },
+  deviceType: { type: Number, default: -1 },  //11-ios, 0-android - 11 is correct for ios
+  deviceModel: { type: String, default: "" },
+  gcmRegId: [],
+  iosRegId: [],
+  iosBadge: { type: Number, default: 0 },
+  version: { type: Number, default: 0 },
+  onesignalId: [],
+  shareLink: { type: String, default: "" },
+  deferLink: { type: String, default: "" },
+  chatStatus: { type: Number, default: 0 },
+  fullLink: { type: String, default: "" },
+  referralLink: { type: String, default: null },
+  lastResetOn: { type: Date, default: null },
+  oldEmail: { type: String, default: "" },
+  oldMobile: { type: String, default: "" },
+  publicActivityLimit: { type: Number, default: 5 },
+  placeId: { type: String },
+  paytmOpenId: { type: String },
+  paidHostName: { type: String, default: "" },
+  paidHostCity: { type: String, default: "" },
+  activityHistory: [
+    {
+      _id: false,
+      activityId: { type: String, unique: true },
+      activityTS: Date
+    }
+  ],
+  lastProcessed: Date,
+  calendarLink: { type: String, default: "" },
+  activityStack: Boolean,  //  config which informs whether user's activities are to be stacked
+  extraFields: [{
+    _id: false,
+    id: { type: String, required: true },
+    value: { type: String, required: true }
+  }],
+  lastContactSyncedAt : {
+    type: Date,
+    default: null
+  },
+  onboardSource: {
+    type: String,
+    enum: ['web', 'android', 'ios', 'others'],
+    default: 'others'
+  }
+}, { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } })
+
+userSchema.index({ 'onesignalId': 1 }, { 'background': true })
+userSchema.index({ 'mobile': 1 })
+userSchema.index({ 'email': 1 }, { collation: { locale: "en", strength: 2 } })  // case insensitive index
+userSchema.index({ 'officialEmail': 1 }, { collation: { locale: "en", strength: 2 } })  // case insensitive index
+
+userSchema.index({ 'oldPlayoId': 1 })
+
+const User = mongoose.model('User', userSchema)
+
+
+module.exports = User

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

@@ -0,0 +1,24 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var userAlertSchema = new Schema({
+  userId: { type: String },
+  id: { type: String },
+  message: { type: String, default: "" },
+  isRead: { type: Boolean, default: false },
+  delete: { type: Boolean, default: false },
+  pic: { type: String, default: "" },
+  data: {
+    url: String
+  },
+  source: { type: String, default: "" },
+  isInvitation: { type: Boolean, default: false },
+  invitationExpiry: Date,
+  expiry: Date,
+  createdTS: { type: Date, default: Date.now },
+  notificationId: { type: String }
+});
+
+userAlertSchema.index({ 'userId': 1 })
+
+module.exports = mongoose.model('UserAlert', userAlertSchema);

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

@@ -0,0 +1,50 @@
+const MONGOOSE = require('mongoose')
+const Schema = MONGOOSE.Schema
+const bcrypt = require("bcrypt")
+const UTIL = require('../util')
+const SALT_WORK_FACTOR = 10
+const userCredentialSchema = new Schema({
+  // _id: false,
+  userId: { type: String, required: true, unique: true },
+  password: String
+})
+
+
+userCredentialSchema.pre('save', function (next) {
+  var user = this;
+
+  // only hash the password if it has been modified (or is new)
+  if (!user.isModified('password')) return next();
+
+  // generate a salt
+  bcrypt.genSalt(SALT_WORK_FACTOR, function (err, salt) {
+    if (err) return next(err);
+
+    // hash the password along with our new salt
+    bcrypt.hash(user.password, salt, function (err, hash) {
+      if (err) return next(err);
+
+      // override the cleartext password with the hashed one
+      user.password = hash;
+      next();
+    });
+  });
+});
+
+userCredentialSchema.methods.comparePassword = function (candidatePassword) {
+  // console.log("incoming password", candidatePassword, this.password)
+  return bcrypt.compare(candidatePassword, this.password).then(res => {
+    if (res)
+      return true
+    else
+      return false
+  }).catch(err => {
+    return err
+  })
+};
+
+
+
+module.exports = MONGOOSE.model('usercredentials', userCredentialSchema)
+
+

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

@@ -0,0 +1,81 @@
+const MONGOOSE = require('mongoose')
+const Schema = MONGOOSE.Schema
+
+const UserFavouriteSchema = new Schema({
+  userId: { type: String, unique: true, required: true },
+  isTempUser: { type: Boolean, default: false },
+  sports: [{
+    _id: false,
+    sportId: { type: String, required: true },
+    selfRating: { type: Number, default: 0, min: 0, max: 5 },
+    rating: { type: Number, default: 0, min: 0, max: 5 },
+    ratingCount: { type: Number, default: 0, min: 0 },
+    matches: { type: Number, default: 0, min: 0 },
+    active: { type: Boolean, default: true },
+    oldCount: { type: Number, default: 0 },    // matched count is added when user reset sport stats
+    timestamp: Date,
+    lastReset: { type: Date },
+    activityRank: { type: Number, default: 0 }
+  }],
+  activityShortlist: [], //list of actvityId
+  venueBookmarks: [],//list of venueIds
+  activityShortlistLog: [],
+  areas: [{
+    _id: false,
+    geoLocation: {
+      type: { type: String },
+      coordinates: []
+    },
+    timestamp: { type: Date, default: Date.now },
+    areaName: { type: String, required: true },
+    type: { type: Number, default: 1 }      // 1 - area, 2 - venue
+  }],
+  areasLog: [
+    {
+      _id: false,
+      geoLocation: {
+        type: { type: String },
+        coordinates: []
+      },
+      timestamp: { type: Date, default: Date.now },
+      areaName: { type: String, required: true },
+      type: { type: Number, default: 1 } // 1- area, 2 - venue
+    }
+  ],
+  blocked: [], //list of userIds whom user blocked
+  isBlocked: [],   //list of userids who blocked user
+  gatewayInfo: [{
+    _id: false,
+    gateway: { type: String, required: true },
+    customerId: { type: String, required: true }
+  }],
+  notificationPref: [{
+    _id: false,
+    category: { type: String, required: true },
+    status: { type: Boolean, required: true }
+  }],
+  lastPlayed: { type: Date, default: null },
+  lastReset: { type: Date, default: null },
+  weeklyHealthkitGoal: [{
+    _id: false,
+    weeklyMinutesGoal: {
+      type: Number,
+      default: 0
+    },
+    lastSetOn: {
+      type: Date,
+      default: null
+    }
+  }],
+  healthkitSettings: {
+    permissions: [],
+    provider: { type: String },
+    permissionProvidedDate: { type: Date, default: null }
+  }
+}, { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } })
+
+UserFavouriteSchema.index({ 'activityShortlist': 1 }, { 'background': true })
+
+
+module.exports = MONGOOSE.model('userFavourites', UserFavouriteSchema)
+

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

@@ -0,0 +1,10 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var OTPSchema = new Schema({
+  mobile: { type: String, required: true, unique: true },
+  ts: { type: String, default: new Date() },
+  otp: { type: Number, required: true }
+});
+
+module.exports = mongoose.model('OTP', OTPSchema);

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

@@ -0,0 +1,22 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+const userReputationSchema = new Schema(
+  {
+    userId: { type: String, primary: true, unique: true },
+    reputations: [{
+      _id: false,
+      reputationId: { type: Number, required: true },
+      upvotes: { type: Number, default: 0, required: true, min: 0 },
+      downvotes: { type: Number, default: 0, required: true, min: 0 }
+    }],
+    noshow: [{
+      _id: false,
+      activityId: { type: String, required: true },
+      timestamp: { type: Date, required: true },
+      status: { type: Boolean, required: true }
+    }]
+  }, { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } }
+)
+
+
+module.exports = MONGOOSE.model("userReputation", userReputationSchema)

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

@@ -0,0 +1,18 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+const accountSchema = new Schema({
+  _id: false,
+  type: Number,   // 0-google , 1-fb
+  link: String,
+  id: String,
+  isActive: { type: Boolean, default: true }
+})
+const userSocialSchema = new Schema({
+  userId: { type: String, unique: true },
+  accounts: [
+    accountSchema
+  ]
+}, { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } })
+
+
+module.exports = MONGOOSE.model("userSocial", userSocialSchema)

package/lib/db_interface/monog/schemas/userSchemas/year.in.playo.js

@@ -0,0 +1,52 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+const yearInPlayoSchema = new Schema({
+    userId: { type: String, unique: true },
+    totalNumberOfGamesPlayed: { type: Number, default: 0 },
+    totalNumberOfHoursPlayed: { type: Number, default: 0 },
+    totalCaloriesBurnt: { type: Number, default: 0 },
+    karma: {
+        totalEarned: { type: Number, default: 0 },
+        bestMonth: String,
+        moneySavedByKarma: { type: Number, default: 0 },
+    },
+    venues: {
+        venuesTried: { type: Number, default: 0 },
+        favoriteVenue: String,
+        totalGamesAtFavouriteVenue: Number
+    },
+    sports: {
+        numberOfSportsPlayed: { type: Number, default: 0 }, // different sports user played last year
+        favoriteSports: String,
+        favouriteSportPlayedCount: { type: Number, default: 0 },
+    },
+    playpals: {
+        newPlayPals: { type: Number, default: 0 },
+        favorite: String,
+        totalGamesWithFavoritePlayPal: { type: Number, default: 0 },
+        topPlaypals: [
+            {
+                userId: String,
+                name: String,
+                profilePicUrl: String
+            }
+        ]
+    },
+    referredUsers: [
+        {
+            userId: String,
+            name: String,
+            profilePicUrl: String,
+            gamesCompleted: { type: Number, default: 0 },
+        }
+    ],
+    leaderBoardRank: { type: Number, default: 0 },
+    year: Number,
+    hours: {},
+    url: String,
+    cityCode: Number
+}, { timestamps: { createdAt: 'createdTS', updatedAt: "modTS" } })
+
+yearInPlayoSchema.index({ 'userId': 1 })
+
+module.exports = MONGOOSE.model("yearinplayo", yearInPlayoSchema)

package/lib/index.js

@@ -1,6 +1,8 @@
 
 /* 
 * Naming terminology - While exporting constants use PascalCase while exporting functions/methods use camelCase
+* This repo should be used as a library for all the common functionalities that are used across the services.
+* This repo should be privatized, no idea why it was public in the first place :(
 */
 module.exports = {
     ratings: require('./ratings/index'),
@@ -17,4 +19,5 @@ module.exports = {
     PLAYO_ERROR_HANDLER: require("./playo.utils/playo.error.handler"),
     PLAYO_HTTP_HANDLER: require("./playo.utils/playo.http.handler"),
     PLAYO_RESPONSE_GENERATOR: require("./playo.utils/playo.res.generator"),
+    PLAYO_MONGO_MODELS: require("./db_interface/mongo/index"),
 };