@mac777/project-pinecone-models 1.1.22 → 1.1.24

package/src/PaymentDetails.ts

@@ -0,0 +1,127 @@
+import mongoose from "mongoose";
+
+/**
+ * Payment Details Schema
+ * Stores payment/payout information separate from User
+ */
+const paymentDetailsSchema = new mongoose.Schema({
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    unique: true,
+    index: true
+  },
+  
+  // Payment Method
+  method: {
+    type: String,
+    enum: ['bkash', 'nagad', 'rocket', 'bank_transfer'],
+    required: true,
+    index: true
+  },
+  
+  // Mobile Money (bKash, Nagad, Rocket)
+  mobileNumber: {
+    type: String,
+    trim: true
+  },
+  accountHolderName: {
+    type: String,
+    trim: true
+  },
+  
+  // Bank Transfer
+  bankName: {
+    type: String,
+    trim: true
+  },
+  accountNumber: {
+    type: String,
+    trim: true
+  },
+  branchName: {
+    type: String,
+    trim: true
+  },
+  routingNumber: {
+    type: String,
+    trim: true
+  },
+  swiftCode: {
+    type: String,
+    trim: true
+  },
+  
+  // Verification
+  verified: {
+    type: Boolean,
+    default: false,
+    index: true
+  },
+  verifiedAt: {
+    type: Date
+  },
+  verifiedBy: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+  rejectionReason: {
+    type: String
+  },
+  
+  // Metadata
+  lastUpdatedBy: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  }
+}, {
+  timestamps: true
+});
+
+// Indexes
+paymentDetailsSchema.index({ userId: 1 });
+paymentDetailsSchema.index({ verified: 1, createdAt: -1 });
+paymentDetailsSchema.index({ method: 1, verified: 1 });
+
+// Pre-save validation: Ensure required fields based on method
+paymentDetailsSchema.pre('save', function(next) {
+  if (this.method === 'bank_transfer') {
+    if (!this.bankName || !this.accountNumber || !this.accountHolderName) {
+      return next(new Error('Bank name, account number, and account holder name are required for bank transfer'));
+    }
+  } else {
+    // Mobile money methods
+    if (!this.mobileNumber || !this.accountHolderName) {
+      return next(new Error('Mobile number and account holder name are required for mobile money'));
+    }
+  }
+  next();
+});
+
+// Methods
+paymentDetailsSchema.methods.markAsVerified = function(verifiedBy: mongoose.Types.ObjectId) {
+  this.verified = true;
+  this.verifiedAt = new Date();
+  this.verifiedBy = verifiedBy;
+  this.rejectionReason = undefined;
+  return this.save();
+};
+
+paymentDetailsSchema.methods.reject = function(reason: string, rejectedBy: mongoose.Types.ObjectId) {
+  this.verified = false;
+  this.verifiedAt = undefined;
+  this.rejectionReason = reason;
+  this.lastUpdatedBy = rejectedBy;
+  return this.save();
+};
+
+paymentDetailsSchema.methods.isMobileMoney = function() {
+  return ['bkash', 'nagad', 'rocket'].includes(this.method);
+};
+
+paymentDetailsSchema.methods.isBankTransfer = function() {
+  return this.method === 'bank_transfer';
+};
+
+export default paymentDetailsSchema;

package/src/PhoneVerification.ts

@@ -0,0 +1,93 @@
+import mongoose from "mongoose";
+
+/**
+ * Phone Verification Schema
+ * Handles OTP generation, verification, and rate limiting
+ */
+const phoneVerificationSchema = new mongoose.Schema({
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    index: true
+  },
+  phoneNumber: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  otp: {
+    type: String,
+    required: true
+  },
+  expiresAt: {
+    type: Date,
+    required: true,
+    index: true
+  },
+  verified: {
+    type: Boolean,
+    default: false
+  },
+  verifiedAt: {
+    type: Date
+  },
+  // Attempt tracking (security)
+  attempts: {
+    type: Number,
+    default: 0
+  },
+  lastAttemptAt: {
+    type: Date
+  },
+  maxAttempts: {
+    type: Number,
+    default: 5
+  },
+  // Rate limiting
+  sentCount: {
+    type: Number,
+    default: 1
+  },
+  lastSentAt: {
+    type: Date,
+    default: Date.now
+  },
+  // Metadata
+  sentFrom: {
+    type: String // IP address
+  }
+}, {
+  timestamps: true
+});
+
+// Indexes
+phoneVerificationSchema.index({ userId: 1, phoneNumber: 1 });
+phoneVerificationSchema.index({ userId: 1, verified: 1 });
+phoneVerificationSchema.index({ phoneNumber: 1, verified: 1 });
+
+// TTL Index: Auto-delete expired OTPs after they expire
+phoneVerificationSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+// Methods
+phoneVerificationSchema.methods.isExpired = function() {
+  return this.expiresAt < new Date();
+};
+
+phoneVerificationSchema.methods.isMaxAttemptsReached = function() {
+  return this.attempts >= this.maxAttempts;
+};
+
+phoneVerificationSchema.methods.incrementAttempts = function() {
+  this.attempts += 1;
+  this.lastAttemptAt = new Date();
+  return this.save();
+};
+
+phoneVerificationSchema.methods.canResend = function(cooldownSeconds = 60) {
+  if (!this.lastSentAt) return true;
+  const cooldownMs = cooldownSeconds * 1000;
+  return Date.now() - this.lastSentAt.getTime() > cooldownMs;
+};
+
+export default phoneVerificationSchema;

package/src/Review.ts

@@ -0,0 +1,268 @@
+import mongoose from 'mongoose';
+
+export interface IReview {
+  eventId: mongoose.Types.ObjectId;
+  userId: mongoose.Types.ObjectId;
+  ticketId: mongoose.Types.ObjectId;
+
+  // Review Content
+  rating: number; // 1-5 stars
+  title: string;
+  comment: string;
+
+  // Context Metadata (smart dual-context approach)
+  reviewContext: {
+    hasCheckedIn: boolean;
+    checkInTime?: Date;
+    ticketTier: string;
+    ticketType: string;
+  };
+
+  // Status & Moderation
+  status: 'pending' | 'approved' | 'hidden' | 'flagged';
+  isVisible: boolean;
+  moderationNotes?: string;
+
+  // Timestamps
+  submittedAt: Date;
+  moderatedAt?: Date;
+  moderatorId?: mongoose.Types.ObjectId;
+
+  // Community Features
+  helpfulVotes: number;
+  reportedCount: number;
+  reports: Array<{
+    userId: mongoose.Types.ObjectId;
+    reason: string;
+    reportedAt: Date;
+  }>;
+}
+
+const reviewSchema = new mongoose.Schema<IReview>({
+  eventId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Event',
+    required: true,
+    index: true
+  },
+
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+    required: true,
+    index: true
+  },
+
+  ticketId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Ticket',
+    required: true,
+    index: true
+  },
+
+  // Review Content
+  rating: {
+    type: Number,
+    required: true,
+    min: 1,
+    max: 5,
+    validate: {
+      validator: Number.isInteger,
+      message: 'Rating must be a whole number'
+    }
+  },
+
+  title: {
+    type: String,
+    required: true,
+    trim: true,
+    maxlength: 100
+  },
+
+  comment: {
+    type: String,
+    required: true,
+    trim: true,
+    maxlength: 1000
+  },
+
+  // Context Metadata
+  reviewContext: {
+    hasCheckedIn: {
+      type: Boolean,
+      required: true
+    },
+    checkInTime: Date,
+    ticketTier: {
+      type: String,
+      required: true
+    },
+    ticketType: {
+      type: String,
+      required: true
+    }
+  },
+
+  // Status & Moderation
+  status: {
+    type: String,
+    enum: ['pending', 'approved', 'hidden', 'flagged'],
+    default: 'pending',
+    index: true
+  },
+
+  isVisible: {
+    type: Boolean,
+    default: true
+  },
+
+  moderationNotes: {
+    type: String,
+    trim: true,
+    maxlength: 500
+  },
+
+  // Timestamps
+  submittedAt: {
+    type: Date,
+    default: Date.now,
+    index: true
+  },
+
+  moderatedAt: Date,
+
+  moderatorId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+
+  // Community Features
+  helpfulVotes: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+
+  reportedCount: {
+    type: Number,
+    default: 0,
+    min: 0
+  },
+
+  reports: [{
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      required: true
+    },
+    reason: {
+      type: String,
+      required: true,
+      enum: ['spam', 'abusive', 'fake', 'irrelevant', 'other']
+    },
+    reportedAt: {
+      type: Date,
+      default: Date.now
+    }
+  }]
+});
+
+// Compound indexes for efficient queries
+reviewSchema.index({ eventId: 1, status: 1, isVisible: 1 });
+reviewSchema.index({ userId: 1, eventId: 1 }, { unique: true }); // One review per user per event
+reviewSchema.index({ submittedAt: -1 });
+reviewSchema.index({ 'reviewContext.hasCheckedIn': 1 });
+
+// Virtual for review type classification
+reviewSchema.virtual('reviewType').get(function() {
+  return this.reviewContext.hasCheckedIn ? 'attended' : 'entry_access';
+});
+
+// Method to mark as helpful
+reviewSchema.methods.markHelpful = function() {
+  this.helpfulVotes += 1;
+  return this.save();
+};
+
+// Method to report review
+reviewSchema.methods.report = function(userId: string, reason: string) {
+  // Check if user already reported
+  const existingReport = this.reports.find((report: any) =>
+    report.userId.toString() === userId
+  );
+
+  if (!existingReport) {
+    this.reports.push({
+      userId: new mongoose.Types.ObjectId(userId),
+      reason,
+      reportedAt: new Date()
+    });
+    this.reportedCount += 1;
+
+    // Auto-flag if too many reports
+    if (this.reportedCount >= 3) {
+      this.status = 'flagged';
+    }
+  }
+
+  return this.save();
+};
+
+// Method for admin moderation
+reviewSchema.methods.moderate = function(moderatorId: string, action: 'approve' | 'hide' | 'flag', notes?: string) {
+  this.moderatorId = new mongoose.Types.ObjectId(moderatorId);
+  this.moderatedAt = new Date();
+
+  switch (action) {
+    case 'approve':
+      this.status = 'approved';
+      this.isVisible = true;
+      break;
+    case 'hide':
+      this.status = 'hidden';
+      this.isVisible = false;
+      break;
+    case 'flag':
+      this.status = 'flagged';
+      this.isVisible = false;
+      break;
+  }
+
+  if (notes) {
+    this.moderationNotes = notes;
+  }
+
+  return this.save();
+};
+
+// Static method to calculate weighted rating for an event
+reviewSchema.statics.calculateWeightedRating = async function(eventId: string) {
+  const reviews = await this.find({
+    eventId: new mongoose.Types.ObjectId(eventId),
+    status: 'approved',
+    isVisible: true
+  });
+
+  if (reviews.length === 0) return 0;
+
+  let totalWeightedRating = 0;
+  let totalWeight = 0;
+
+  reviews.forEach((review: any) => {
+    const weight = review.reviewContext.hasCheckedIn ? 1.0 : 0.6;
+    totalWeightedRating += review.rating * weight;
+    totalWeight += weight;
+  });
+
+  return totalWeight > 0 ? totalWeightedRating / totalWeight : 0;
+};
+
+// Pre-save middleware to set default status
+reviewSchema.pre('save', function(next) {
+  if (this.isNew && !this.status) {
+    this.status = 'pending';
+  }
+  next();
+});
+
+export default reviewSchema;