playov2-js-utilities 0.3.70 → 0.3.73

package/lib/db_interface/mongo/schemas/gamebookSchemas/message.requests.js

@@ -1,29 +1,29 @@
-const Mongoose = require('mongoose');
-const Schema = Mongoose.Schema;
-const messagerequestSchema = new Schema(
-    {
-        receiverId: {  // person who recieves the message request to be acted upon
-            type: String,
-            required: true
-        },
-        senderId: {  //
-            type: String,
-            required: true
-        },
-        message: {
-            type: String,
-            required: true
-        },
-        status: {
-            type: String,
-            required: true,
-            enum: ['pending', 'deleted', 'blocked', 'accepted'],
-            default: 'pending'
-        }
-
-    }, { timestamps: { createdAt: "createdTS", updatedAt: "modTS" } }
-);
-
-module.exports = Mongoose.model('messagerequests', messagerequestSchema);
-
-// compound index on receiverId, 
+const Mongoose = require('mongoose');
+const Schema = Mongoose.Schema;
+const messagerequestSchema = new Schema(
+    {
+        receiverId: {  // person who recieves the message request to be acted upon
+            type: String,
+            required: true
+        },
+        senderId: {  //
+            type: String,
+            required: true
+        },
+        message: {
+            type: String,
+            required: true
+        },
+        status: {
+            type: String,
+            required: true,
+            enum: ['pending', 'deleted', 'blocked', 'accepted'],
+            default: 'pending'
+        }
+
+    }, { timestamps: { createdAt: "createdTS", updatedAt: "modTS" } }
+);
+
+module.exports = Mongoose.model('messagerequests', messagerequestSchema);
+
+// compound index on receiverId, 

package/lib/db_interface/mongo/schemas/gamebookSchemas/nonPlayoExpenseUsers.js

@@ -1,14 +1,14 @@
-const MONGOOSE = require("mongoose");
-const Schema = MONGOOSE.Schema;
-const nonPlayoExpenseUsersSchema = new Schema(
-    {
-        userId: {type: String, require: true},
-        name: {type: String, require: true},
-        activityId: {type: String, require: true}
-    },
-    {timestamps: {createdAt: "createdTS", updatedAt: "modTS"}}
-);
-
-nonPlayoExpenseUsersSchema.index({userId: 1, activityId: 1});
-
-module.exports = MONGOOSE.model("nonPlayoExpenseUsers", nonPlayoExpenseUsersSchema);
+const MONGOOSE = require("mongoose");
+const Schema = MONGOOSE.Schema;
+const nonPlayoExpenseUsersSchema = new Schema(
+    {
+        userId: {type: String, require: true},
+        name: {type: String, require: true},
+        activityId: {type: String, require: true}
+    },
+    {timestamps: {createdAt: "createdTS", updatedAt: "modTS"}}
+);
+
+nonPlayoExpenseUsersSchema.index({userId: 1, activityId: 1});
+
+module.exports = MONGOOSE.model("nonPlayoExpenseUsers", nonPlayoExpenseUsersSchema);

package/lib/db_interface/mongo/schemas/gamebookSchemas/playpals.js

@@ -1,69 +1,69 @@
-const MONGOOSE = require('mongoose');
-const Schema = MONGOOSE.Schema;
-const playpalSchema = new Schema(
-    {
-        userId: { type: String, required: true },
-        palId: { type: String, required: true },
-        ratings: [
-            {
-                _id: false,
-                sportId: { type: String, required: true },
-                previousRating: { type: Number, default: 0 },
-                rating: { type: Number, default: 0 },
-                timestamp: Date,
-                sportRemoved: { type: Boolean, default: false }
-            }
-        ],
-        blocked: { type: Boolean, default: false },  // true - if user blocks playpal
-        removed: { type: Boolean, default: false },
-        isBlocked: { type: Boolean, default: false }, // true - if playpal blocks user
-        activities: [],
-        reputation: [{
-            _id: false,
-            reputationId: Number,
-            value: Number,
-            timestamp: Date
-        }],
-        reputationLog: [{
-            _id: false,
-            log: [{
-                _id: false,
-                reputationId: Number,
-                value: Number,
-                timestamp: Date
-            }]
-        }],
-        expenses: [{
-            _id: false,
-            activityId: { type: String, required: true },
-            amount: { type: Number, default: 0 },
-            paidAmount: { type: Number, default: 0 },
-            currency: { type: String, default: "" },
-            comments: []
-        }],
-        isNewPal: {
-            type: Boolean,
-            default: false
-        },
-        lastMutedAt: {
-            type: Date,
-            default: null
-        },
-        mutedTill: {
-            type: Date,
-            default: null
-        },
-        tags: {
-            type: Array,
-            default: []
-        },
-        createdTS: { type: Date, default: Date.now },
-        modTS: { type: Date, default: Date.now },
-        lastPlayed: { type: Date, default: Date.now },
-    }, { timestamps: { createdAt: "createdTS", updatedAt: "modTS" } }
-);
-
-playpalSchema.index({ 'userId': 1 });
-playpalSchema.index({ 'palId': 1 });
-
-module.exports = MONGOOSE.model('playpal', playpalSchema);
+const MONGOOSE = require('mongoose');
+const Schema = MONGOOSE.Schema;
+const playpalSchema = new Schema(
+    {
+        userId: { type: String, required: true },
+        palId: { type: String, required: true },
+        ratings: [
+            {
+                _id: false,
+                sportId: { type: String, required: true },
+                previousRating: { type: Number, default: 0 },
+                rating: { type: Number, default: 0 },
+                timestamp: Date,
+                sportRemoved: { type: Boolean, default: false }
+            }
+        ],
+        blocked: { type: Boolean, default: false },  // true - if user blocks playpal
+        removed: { type: Boolean, default: false },
+        isBlocked: { type: Boolean, default: false }, // true - if playpal blocks user
+        activities: [],
+        reputation: [{
+            _id: false,
+            reputationId: Number,
+            value: Number,
+            timestamp: Date
+        }],
+        reputationLog: [{
+            _id: false,
+            log: [{
+                _id: false,
+                reputationId: Number,
+                value: Number,
+                timestamp: Date
+            }]
+        }],
+        expenses: [{
+            _id: false,
+            activityId: { type: String, required: true },
+            amount: { type: Number, default: 0 },
+            paidAmount: { type: Number, default: 0 },
+            currency: { type: String, default: "" },
+            comments: []
+        }],
+        isNewPal: {
+            type: Boolean,
+            default: false
+        },
+        lastMutedAt: {
+            type: Date,
+            default: null
+        },
+        mutedTill: {
+            type: Date,
+            default: null
+        },
+        tags: {
+            type: Array,
+            default: []
+        },
+        createdTS: { type: Date, default: Date.now },
+        modTS: { type: Date, default: Date.now },
+        lastPlayed: { type: Date, default: Date.now },
+    }, { timestamps: { createdAt: "createdTS", updatedAt: "modTS" } }
+);
+
+playpalSchema.index({ 'userId': 1 });
+playpalSchema.index({ 'palId': 1 });
+
+module.exports = MONGOOSE.model('playpal', playpalSchema);

package/lib/db_interface/mongo/schemas/gamebookSchemas/postActivity.js

@@ -1,51 +1,51 @@
-const MONGOOSE = require("mongoose");
-const Schema = MONGOOSE.Schema;
-const postActivitySchema = new Schema(
-	{
-		activityId: { type: String, required: true, primary: true },
-		date: { type: Date }, // activity date
-		timing: { type: Number }, // activity timing
-		startTime: { type: Date }, // activity startTime
-		endTime: { type: Date }, //activity endTime
-		userId: { type: String, required: true, primary: true },
-		location: { type: String, default: "" },
-		sportId: String,
-		hostId: { type: String, default: "" },
-		matchHappened: { type: Boolean, default: true },
-		matchRating: { type: Number, default: -1 }, // -1 nothing, 0-thumbsdown, 1-thumbsup
-		userPlayed: { type: Boolean, default: true }, // updated if user rates himself noshow and after calculating majority of noshow
-		expired: { type: Boolean, default: false },
-		pals: [
-			{
-				_id: false,
-				palId: { type: String, require: true },
-				noshow: { type: Boolean, default: false },
-				noshowSwitch: { type: Boolean, default: false }, // to show noshow switch or not
-				rating: { type: Number, default: 0 },
-				newPlaypal: { type: Boolean, default: false },
-				timestamp: { type: Date, default: Date.now },
-				reputation: [
-					{
-						_id: false,
-						reputationId: Number,
-						value: Number
-					}
-				],
-				userName: String,
-				firstRatedOn: { type: Date, default: null },
-				isRemoved: { type: Boolean, default: false }, // made true if this pal removes sport from his fav
-				userPresent : { type: Boolean, default: null } // if false user explicitly states the user wasn't present in game which adds user's rating to be considered for no-show pool
-			}
-		],
-		cancelled: { type: Boolean, default: false },
-		noshow: { type: Boolean, default: false },
-		createdTS: { type: Date, default: Date.now },
-		modTS: { type: Date, default: Date.now },
-		removed: { type: Boolean, default: false } // made true if this user removes this sport from his fav
-	},
-	{ timestamps: { createdAt: "createdTS", updatedAt: "modTS" } }
-);
-
-postActivitySchema.index({ userId: 1, activityId: 1 }, { unique: true });
-
-module.exports = MONGOOSE.model("postActivity", postActivitySchema);
+const MONGOOSE = require("mongoose");
+const Schema = MONGOOSE.Schema;
+const postActivitySchema = new Schema(
+	{
+		activityId: { type: String, required: true, primary: true },
+		date: { type: Date }, // activity date
+		timing: { type: Number }, // activity timing
+		startTime: { type: Date }, // activity startTime
+		endTime: { type: Date }, //activity endTime
+		userId: { type: String, required: true, primary: true },
+		location: { type: String, default: "" },
+		sportId: String,
+		hostId: { type: String, default: "" },
+		matchHappened: { type: Boolean, default: true },
+		matchRating: { type: Number, default: -1 }, // -1 nothing, 0-thumbsdown, 1-thumbsup
+		userPlayed: { type: Boolean, default: true }, // updated if user rates himself noshow and after calculating majority of noshow
+		expired: { type: Boolean, default: false },
+		pals: [
+			{
+				_id: false,
+				palId: { type: String, require: true },
+				noshow: { type: Boolean, default: false },
+				noshowSwitch: { type: Boolean, default: false }, // to show noshow switch or not
+				rating: { type: Number, default: 0 },
+				newPlaypal: { type: Boolean, default: false },
+				timestamp: { type: Date, default: Date.now },
+				reputation: [
+					{
+						_id: false,
+						reputationId: Number,
+						value: Number
+					}
+				],
+				userName: String,
+				firstRatedOn: { type: Date, default: null },
+				isRemoved: { type: Boolean, default: false }, // made true if this pal removes sport from his fav
+				userPresent : { type: Boolean, default: null } // if false user explicitly states the user wasn't present in game which adds user's rating to be considered for no-show pool
+			}
+		],
+		cancelled: { type: Boolean, default: false },
+		noshow: { type: Boolean, default: false },
+		createdTS: { type: Date, default: Date.now },
+		modTS: { type: Date, default: Date.now },
+		removed: { type: Boolean, default: false } // made true if this user removes this sport from his fav
+	},
+	{ timestamps: { createdAt: "createdTS", updatedAt: "modTS" } }
+);
+
+postActivitySchema.index({ userId: 1, activityId: 1 }, { unique: true });
+
+module.exports = MONGOOSE.model("postActivity", postActivitySchema);

package/lib/db_interface/mongo/schemas/gamebookSchemas/tags.js

@@ -1,13 +1,13 @@
-const MONGOOSE = require('mongoose');
-const { Schema } = MONGOOSE;
-
-const tagSchema = new Schema({
-    tagId: { type: String, required: true },
-    tagName: { type: String, required: true },
-    tagColor: { type: String, required: true },
-    ownerId: {type: String, required: true},
-    isSystemTag: { type: Boolean, default: false },
-    isDeleted: { type: Boolean, default: false },
-}, { timestamps: { createdAt: 'createdTS', updatedAt: 'modTS' } });
-
+const MONGOOSE = require('mongoose');
+const { Schema } = MONGOOSE;
+
+const tagSchema = new Schema({
+    tagId: { type: String, required: true },
+    tagName: { type: String, required: true },
+    tagColor: { type: String, required: true },
+    ownerId: {type: String, required: true},
+    isSystemTag: { type: Boolean, default: false },
+    isDeleted: { type: Boolean, default: false },
+}, { timestamps: { createdAt: 'createdTS', updatedAt: 'modTS' } });
+
 module.exports = MONGOOSE.model('tag', tagSchema);

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

@@ -1,26 +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);
-
+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/mongo/schemas/userSchemas/_userIndex.js

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

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

@@ -1,12 +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)
-
-
+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/mongo/schemas/userSchemas/city.js

@@ -1,62 +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);
+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);