playov2-js-utilities 0.3.63 → 0.3.65

package/lib/db_interface/mongo/index.js

@@ -1,4 +1,6 @@
 module.exports = {
-    USER_MODELS: require('./userSchemas/_userIndex.js'),
-    ACTIVITY_MODELS: require('./activitySchemas/_activityIndex.js')
+    USER_MODELS: require('./schemas/userSchemas/_userIndex.js'),
+    ACTIVITY_MODELS: require('./schemas/activitySchemas/_activityIndex.js'),
+    VENUE_MODELS: require('./schemas/venueSchemas/_venueIndex.js'),
+    GAMEBOOK_MODELS: require('./schemas/gamebookSchemas/_gamebookIndex.js'),
 }

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

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

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

@@ -0,0 +1,3 @@
+module.exports = {
+    playpals: require('./playpals'),
+}

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

@@ -0,0 +1,20 @@
+const MONGOOSE = require("mongoose")
+const Schema = MONGOOSE.Schema
+
+const activityNotesSchema = new Schema({
+  activityId: String,
+  userId: String,
+  notes: [{
+    _id: false,
+    noteId: String,
+    note: String,
+    timestamp: Date,
+    isRemoved: Boolean
+  }],
+  createdTS:{type:Date,default:Date.now},
+  modTS:{type:Date,default:Date.now}
+},{timestamps:{createdAt:"createdTS",updatedAt:"modTS"}})
+
+activityNotesSchema.index({ 'activityId': 1 })
+
+module.exports = MONGOOSE.model("activityNotes", activityNotesSchema)

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

@@ -0,0 +1,36 @@
+const MONGOOSE = require("mongoose");
+const Schema = MONGOOSE.Schema;
+const expenseSchema = new Schema(
+    {
+        activityId: {type: String, require: true},
+        costHead: {type: String, require: true},
+        amount: {type: Number, require: true},
+        currency: {type: String, require: true},
+        payerId: {type: String, require: true},
+        payerName: {type: String, require: true},
+        authorId: {type: String, require: true},
+        authorName: {type: String, require: true},
+        split: [
+            {
+                _id: false,
+                userId: {type: String, require: true},
+                username: {type: String, require: true},
+                paidAmount: {type: Number, default: 0}
+            }
+        ],
+        comments: [
+            {
+                _id: false,
+                userId: {type: String, require: true},
+                comment: {type: String, require: false},
+                timestamp: {type: Date, require: true}
+            }
+        ],
+        isDeleted: {type: Boolean, default: false}
+    },
+    {timestamps: {createdAt: "createdTS", updatedAt: "modTS"}}
+);
+
+expenseSchema.index({activityId: 1, payerId: 1});
+
+module.exports = MONGOOSE.model("expenses", expenseSchema);

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

@@ -0,0 +1,13 @@
+const MONGOOSE = require("mongoose");
+const Schema = MONGOOSE.Schema;
+const expenseLogSchema = new Schema(
+    {
+        activityId: {type: String, require: true},
+        log: {type: String, require: true}
+    },
+    {timestamps: {createdAt: "createdTS", updatedAt: "modTS"}}
+);
+
+expenseLogSchema.index({activityId: 1});
+
+module.exports = MONGOOSE.model("expenseLog", expenseLogSchema);

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

@@ -0,0 +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, 

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

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

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

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

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

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

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

@@ -0,0 +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' } });
+
+module.exports = MONGOOSE.model('tag', tagSchema);

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

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

package/lib/db_interface/mongo/schemas/venueSchemas/_venueIndex.js

@@ -0,0 +1,4 @@
+module.exports = {
+    venueMembers: require('./venueMembers'),
+    venues: require('./venue'),
+}

package/lib/db_interface/mongo/schemas/venueSchemas/ameneties.js

@@ -0,0 +1,9 @@
+const mongoose = require("mongoose")
+const Schema = mongoose.Schema
+const amenetiesSchema = new Schema({
+    amenityId: Number,
+    amenityText: String
+})
+
+module.exports = mongoose.model("Amenties", amenetiesSchema)
+

package/lib/db_interface/mongo/schemas/venueSchemas/cityArea.js

@@ -0,0 +1,45 @@
+const MONGOOSE = require("mongoose");
+const Schema = MONGOOSE.Schema;
+
+const cityAreaSchema = new Schema({
+    id: { type: String, required: true },
+    venues: [{   // GT venues - represented by venueIds
+        _id: false,
+        venueId: {
+            type: String,
+            required: true
+        },
+ /*DEPRECATED!*/       gtTrialMaxCount: {  // max GT trial game per person --- deprecated!! - using percentage on area basis now
+            type: Number,
+            default: 0,
+            required: true
+        },
+        enabled: {
+            type: Boolean,
+            default: true
+        }
+    }],
+    cityCode: { type: Number, required: true },
+    name: { type: String, required: true },
+    geoLocation: {
+        type: { type: String },
+        coordinates: []
+    },
+    areaIllustrationImage: { type: String, required: false },
+    active: { type: Boolean, default: true },
+    gtTrialSteps: [{
+        _id: false,
+        discountPercentageAvailable: {
+            type: Number,
+            default: 0,
+            min: 0,
+            max: 100
+        },
+        step: {
+            type: Number,
+            default: 1
+        }
+    }]
+});
+
+module.exports = MONGOOSE.model("cityArea", cityAreaSchema);

package/lib/db_interface/mongo/schemas/venueSchemas/clubConstraints.js

@@ -0,0 +1,17 @@
+const MONGOOSE = require("mongoose");
+const Schema = MONGOOSE.Schema;
+
+const clubConstraintsSchema = new Schema(
+    {
+        venueId: {type: String, require: true},
+        config: {
+            bookingCheckout: {
+                isEmailMandatory: {type: Boolean},
+                isUniqueIdEnabled: {type: Boolean},
+            }
+        }
+    },
+    {strict: false}
+);
+
+module.exports = MONGOOSE.model("clubConstraints", clubConstraintsSchema);

package/lib/db_interface/mongo/schemas/venueSchemas/corporateOffer.js

@@ -0,0 +1,17 @@
+const mongoose = require("mongoose")
+const Schema = mongoose.Schema
+
+const corporateOfferSchema = new Schema(
+  {
+    id:{type:String,unique:true,required:true},
+    name:{type:String,required:true},
+    logoUrl:{type:String,required:true},
+    users:[String],
+    percentage:{type:Number,required:true},
+    upto:{type:Number,required:true},
+    terms:{type:String}
+    
+  }
+)
+
+module.exports=mongoose.model("corporateOffer",corporateOfferSchema)

package/lib/db_interface/mongo/schemas/venueSchemas/couponOffers.js

@@ -0,0 +1,39 @@
+const mongoose = require('mongoose');
+const { Schema, model } = mongoose;
+
+const couponOffersSchema = new Schema({
+
+    id: { type: String, required: true, unique: true },
+    offerName: { type: String, required: true }, // title of the offer kind of like short description
+    description: { type: String, required: true }, // description of the offer
+
+    couponCode: { type: String, required: true },
+
+    couponAmount: { type: Number, default: null },
+    couponLimit: { type: Number, default: null },
+    couponPercent: { type: Number, default: null },
+
+    detailDescription: { type: String, default: "" },
+
+    venueIds: [{ type: String }],
+    allVenues: { type: Boolean, default: false }, // offers valid for all venues
+
+    sportIds: [{ type: String }],
+    universal: { type: Boolean, default: false },
+    countryCodes: { type: String },
+           
+    allCities: { type: Boolean, default: false },
+    cityCodes: [{ type: String }],
+
+    active: { type: Boolean, default: true },
+    startDate: { type: Date, default: Date.now },
+    expiryDate: { type: Date, default: "" },
+
+
+}, { timestamps: true });
+
+couponOffersSchema.index({ id: 1 });
+couponOffersSchema.index({ venueIds: 1 });
+couponOffersSchema.index({ cityCodes: 1, sportIds: 1, expiryDate: 1, startDate: 1 });
+
+module.exports = model('couponOffers', couponOffersSchema);

package/lib/db_interface/mongo/schemas/venueSchemas/gamebagMember.js

@@ -0,0 +1,12 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const GamebagMemberSchema = new Schema({
+  venueId: { type: String, required: true, unique: true },
+  users: [{
+    _id: false,
+    mobile: String,
+  }]
+});
+
+module.exports = mongoose.model('GamebagMember', GamebagMemberSchema);

package/lib/db_interface/mongo/schemas/venueSchemas/offer.js

@@ -0,0 +1,48 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const offerSchema = new Schema({
+  id : {type : String, required : true, unique : true},
+  imageUrl: { type: String, required: true },
+  shareMsg: { type: String, required: true },
+  offerType: { type: String, required: true },
+  offerContent: { type: String, required: true },
+  coupon: { type: String, default: "" },
+  offerName: { type: String, required: true },
+  city: { type: String, required: true },
+  cityCode: { type: Number, default: 1 },
+  multiCity: { type: Boolean, default: false },
+  cityLat: { type: Number, default: null },
+  cityLng: { type: Number, default: null },
+  sports: String,
+  activeKey: { type: String, default: "" },
+  active: { type: Boolean, default: false },
+  expiry: { type: Date, default: null },
+  startDate: { type: Date, default: Date.now },
+  shareLink: { type: String, default: "" },
+  deferLink: { type: String, default: "" },
+  infoData: [{
+    _id: false,
+    howTo: { type: String, default: "" },
+    coupon: { type: String, default: "" },
+    type: { type: String, default: "" },
+    content: { type: String, default: "" },
+    validity: { type: String, default: "" },
+    action: { type: String, default: "" }
+
+  }],
+  terms: { type: String, default: "" },
+  countryCode: { type: String, default: "+91" },
+  createdTS: { type: Date, default: Date.now },
+  geoLocation : {
+    type : { type: String },
+    coordinates : []
+  },
+  venueId: [String]
+
+});
+
+offerSchema.index({ geoLocation: "2dsphere" })
+// offerSchema.index({ expiry: 1 })
+
+module.exports = mongoose.model('Offer', offerSchema);

package/lib/db_interface/mongo/schemas/venueSchemas/thirdParty.js

@@ -0,0 +1,13 @@
+const Mongoose = require("mongoose")
+const Schema = Mongoose.Schema
+
+const thirdPartySchema = new Schema(
+    {
+        domain:{type:String,required:true},
+        venueId:{type:String,required:true}
+    }
+)
+
+thirdPartySchema.index({domain:1})
+
+module.exports = Mongoose.model("thirdParty",thirdPartySchema)

package/lib/db_interface/mongo/schemas/venueSchemas/venue.js

@@ -0,0 +1,134 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const VenueSchema = new Schema({
+  id: { type: String, required: true, unique: true },
+  oldPlayoId: { type: String, default: "", required: true },
+  name: { type: String, required: true, validate: /[A-Za-z]/ },
+  timings: { type: String, required: true },
+  amenities: [], // { type : String, default : null }, // locker, washroom, rentAcc, parking, trainer, firstAid, beverage
+  addInfo: String,
+  geoLocation: {
+    type: { type: String },
+    coordinates: []
+  },
+  // placeId : { type : String, default : '' },
+  address: { type: String, required: true },
+  area: { type: String, required: true },
+  category: { type: Number, required: true, min: 0, max: 3 }, //0 - unverified, 1 - verified, 2 - partner, 3 - member
+  // relationSummary : String,
+  city: { type: String, required: true, validate: /[A-Za-z]/ },
+  cityCode: { type: Number, default: 1 },
+  country: { type: String, required: true, validate: /[A-Za-z]/ },
+  state: String,
+  zipCode: { type: String },
+  inquiryPhone: { type: String, default: '' },
+  inquiryType: { type: Number, default: -1 }, // -1 - No SMS, 0 - Only venue, 1 - Only user, 2 - Both (send to user is not enabled)
+  email: [],
+  phone: [],
+  sports: [],
+  avgRating: { type: Number, default: 0, min: 0, max: 5 },
+  ratingCount: { type: Number, default: 0 },
+  // restricted : { type : Number, default : 0, min : 0, max : 1 },
+  s3Folder: String,
+  // bookType : { type : Number }, // 0 - Book, 1 - Reserve, 2 - Member/Book, 3 - Ticketing, 4 - Regular
+  infoData: [{
+    _id: false,
+    key: { type: String, required: true },
+    value: { type: String, required: true },
+    displayType: { type: Number }, // call-1, inquire-2, book-3, buy-4, join-5, enroll-6, RSVP-7, 
+    type: { type: Number }, // call-1, inquire-2, book-3, pass-4, webview_inapp-5, webview_outside_app-6, bulk-7
+    caption: { type: String },
+    content: { type: String },
+    bookType: { type: Number }, // 0 - Book, 1 - Reserve, 2 - Member/Book, 3 - Ticketing, 4 - Regular, 6 - Bulk
+    sportId: { type: String, default: "" },
+    moreData: [{
+      _id: false,
+      key: { type: String, required: true },
+      value: { type: String, required: true },
+    }],
+  }],
+  functionData: [{
+    _id: false,
+    displayType: { type: Number, required: true }, // call-1, inquire-2, book-3, buy-4, join-5, enroll-6, RSVP-7
+    type: { type: Number, required: true }, // call-1, inquire-2, book-3, pass-4, webview_inapp-5, webview_outside_app-6, bulk-7
+    caption: { type: String, required: true },
+    content: { type: String, default: "" },
+    priority: { type: Number, required: true },
+    bookType: { type: Number }, // 0 - Book, 1 - Reserve, 2 - Member/Book, 3 - Ticketing, 4 - Regular, 6 - Bulk
+    sportId: { type: String, default: "" },
+    popupText: { type: String, default: '' }
+  }],
+  keywords: [{
+    _id: false,
+    key: { type: String, required: true },
+    active: { type: Boolean, required: true }
+  }],
+  images: [{
+    _id: false,
+    url: { type: String }
+  }],
+  videos: {
+    type: [
+      {
+        _id: false,
+        videoUrl: { type: String },
+        thumbnail: { type: String },
+      }
+    ],
+    default: []
+  },
+  coverImage: { type: String, default: "" },
+  logoImg: { type: String, default: "" },
+  mapImage: { type: String, default: "" },
+  tags: [
+    { tagId: String, expiry: Date }
+  ],
+  search: { type: String, default: "" },
+  // dateLimit : {type : Number, default : 14},
+  createdTS: { type: Date, default: Date.now },
+  modTS: { type: Date, default: Date.now },
+  sponsored: { type: String, default: "" },
+  bulkSponsored: { type: String, default: "" },
+  active: { type: Boolean, default: true },
+  // oldId : { type : String, default : ""},
+  activatedOn: Date,
+  sponsoredExpiry: Date,
+  bulkSponsoredExpiry: Date,
+  description: { type: String, default: "" },
+  members: { type: Boolean, default: false }, // if true, show only to users who are members of the venue
+  shareLink: { type: String, default: "" },
+  deferLink: { type: String, default: "" },
+  fullLink: { type: String, default: "" },
+  priority: { type: Number, default: null },
+  googleMapLink: { type: String, default: "" },
+  remarks: { type: String, default: "" },
+  website: { type: String },
+  sponsoredRadius: { type: Number, default: 0 },
+  isSafeAndHygiene: { type: Boolean, default: false },
+  bulkSponsoredRadius: { type: Number, default: 0 },
+  googlePlusCode: { type: String, default: "" },
+  products: [{
+    _id: false,
+    name: { type: String, required: true },
+    priority: { type: Number, default: 0 },
+    icon: { type: String, required: true },
+    info: { type: String, required: true },
+    url: { type: String, required: true },
+    type: { type: String, required: true }  // 0 - gear, 1 - Beverage, 2 - food
+  }],
+  bnpl: { type: Boolean, default: false },
+  partialPay: { type: Boolean, default: false },
+  activityCount: { type: Number, default: 0 },
+  activityCountLastSyncDate: {type: Date, default: new Date()},
+  textSearchableField: [String]
+});
+
+VenueSchema.index({ geoLocation: "2dsphere" });
+VenueSchema.index({ oldPlayoId: 1 });
+
+/**
+ * keys to text index - textSearchableField, array containing texts on which search is going to take place
+ */
+
+module.exports = mongoose.model('Venue', VenueSchema);

package/lib/db_interface/mongo/schemas/venueSchemas/venueEnquires.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var VenueEnquirySchema = new Schema({
+
+    userId: { type: String },
+    venueId: { type: String, required: true },
+    mobile: { type: String },
+    email: { type: String },
+    name: { type: String },
+    createdTS: { type: Date, default: Date.now },
+    comments: [{
+        _id: false,
+        msg: { type: String, required: true },
+        createdBY: { type: String, default: 'user' },
+        createdTS: { type: Date, default: Date.now }
+    }],
+    resolved: { type: Boolean, default: false },
+    inquiryType: { type: String, default: '' },
+    inquiryText: { type: String, default: '' }
+});
+
+module.exports = mongoose.model('VenueEnquiry', VenueEnquirySchema);

package/lib/db_interface/mongo/schemas/venueSchemas/venueMembers.js

@@ -0,0 +1,15 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const VenueMemberSchema = new Schema({
+
+  venueId: {type : String, required: true, unique: true},
+  members: [{
+    _id: false,
+    userId: String,
+  }],
+  createdTS: { type: Date, default: Date.now },
+  modTS: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('VenueMember', VenueMemberSchema);

package/lib/db_interface/mongo/schemas/venueSchemas/venueRating.js

@@ -0,0 +1,18 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const VenueRatingSchema = new Schema({
+  venueId: {type : String, required: true, unique: true},
+  ratings: [{
+    _id: false,
+    userId: String,
+    rating: { type: Number, min: 1, max: 5 },
+    remarks: { type: String, default: '' },
+    oldRatings: [],
+    ratedOn: Date
+  }],
+  createdTS: { type: Date, default: Date.now },
+  modTS: { type: Date, default: Date.now }
+});
+
+module.exports = mongoose.model('VenueRating', VenueRatingSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playov2-js-utilities",
-  "version": "0.3.63",
+  "version": "0.3.65",
   "description": "Private package for JS utility functions",
   "main": "index.js",
   "scripts": {