@mac777/project-pinecone-models 1.1.22 → 1.1.24

package/dist/Payout.d.ts

@@ -18,6 +18,10 @@ declare const payoutSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     platformFee?: number | null | undefined;
     refundAmount?: number | null | undefined;
     failedAt?: NativeDate | null | undefined;
+    bankName?: string | null | undefined;
+    accountNumber?: string | null | undefined;
+    branchName?: string | null | undefined;
+    routingNumber?: string | null | undefined;
     grossRevenue?: number | null | undefined;
     netPayout?: number | null | undefined;
     totalOrders?: number | null | undefined;
@@ -28,11 +32,7 @@ declare const payoutSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     approvedAt?: NativeDate | null | undefined;
     rejectedBy?: mongoose.Types.ObjectId | null | undefined;
     rejectedAt?: NativeDate | null | undefined;
-    accountNumber?: string | null | undefined;
     accountName?: string | null | undefined;
-    bankName?: string | null | undefined;
-    branchName?: string | null | undefined;
-    routingNumber?: string | null | undefined;
     initiatedAt?: NativeDate | null | undefined;
     completedAt?: NativeDate | null | undefined;
     transactionId?: string | null | undefined;
@@ -56,6 +56,10 @@ declare const payoutSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     platformFee?: number | null | undefined;
     refundAmount?: number | null | undefined;
     failedAt?: NativeDate | null | undefined;
+    bankName?: string | null | undefined;
+    accountNumber?: string | null | undefined;
+    branchName?: string | null | undefined;
+    routingNumber?: string | null | undefined;
     grossRevenue?: number | null | undefined;
     netPayout?: number | null | undefined;
     totalOrders?: number | null | undefined;
@@ -66,11 +70,7 @@ declare const payoutSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     approvedAt?: NativeDate | null | undefined;
     rejectedBy?: mongoose.Types.ObjectId | null | undefined;
     rejectedAt?: NativeDate | null | undefined;
-    accountNumber?: string | null | undefined;
     accountName?: string | null | undefined;
-    bankName?: string | null | undefined;
-    branchName?: string | null | undefined;
-    routingNumber?: string | null | undefined;
     initiatedAt?: NativeDate | null | undefined;
     completedAt?: NativeDate | null | undefined;
     transactionId?: string | null | undefined;
@@ -96,6 +96,10 @@ declare const payoutSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     platformFee?: number | null | undefined;
     refundAmount?: number | null | undefined;
     failedAt?: NativeDate | null | undefined;
+    bankName?: string | null | undefined;
+    accountNumber?: string | null | undefined;
+    branchName?: string | null | undefined;
+    routingNumber?: string | null | undefined;
     grossRevenue?: number | null | undefined;
     netPayout?: number | null | undefined;
     totalOrders?: number | null | undefined;
@@ -106,11 +110,7 @@ declare const payoutSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     approvedAt?: NativeDate | null | undefined;
     rejectedBy?: mongoose.Types.ObjectId | null | undefined;
     rejectedAt?: NativeDate | null | undefined;
-    accountNumber?: string | null | undefined;
     accountName?: string | null | undefined;
-    bankName?: string | null | undefined;
-    branchName?: string | null | undefined;
-    routingNumber?: string | null | undefined;
     initiatedAt?: NativeDate | null | undefined;
     completedAt?: NativeDate | null | undefined;
     transactionId?: string | null | undefined;

package/dist/PhoneVerification.d.ts

@@ -0,0 +1,54 @@
+import mongoose from "mongoose";
+/**
+ * Phone Verification Schema
+ * Handles OTP generation, verification, and rate limiting
+ */
+declare const phoneVerificationSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    userId: mongoose.Types.ObjectId;
+    expiresAt: NativeDate;
+    verified: boolean;
+    attempts: number;
+    phoneNumber: string;
+    otp: string;
+    maxAttempts: number;
+    sentCount: number;
+    lastSentAt: NativeDate;
+    verifiedAt?: NativeDate | null | undefined;
+    lastAttemptAt?: NativeDate | null | undefined;
+    sentFrom?: string | null | undefined;
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    userId: mongoose.Types.ObjectId;
+    expiresAt: NativeDate;
+    verified: boolean;
+    attempts: number;
+    phoneNumber: string;
+    otp: string;
+    maxAttempts: number;
+    sentCount: number;
+    lastSentAt: NativeDate;
+    verifiedAt?: NativeDate | null | undefined;
+    lastAttemptAt?: NativeDate | null | undefined;
+    sentFrom?: string | null | undefined;
+} & mongoose.DefaultTimestampProps>, {}, mongoose.ResolveSchemaOptions<{
+    timestamps: true;
+}>> & mongoose.FlatRecord<{
+    userId: mongoose.Types.ObjectId;
+    expiresAt: NativeDate;
+    verified: boolean;
+    attempts: number;
+    phoneNumber: string;
+    otp: string;
+    maxAttempts: number;
+    sentCount: number;
+    lastSentAt: NativeDate;
+    verifiedAt?: NativeDate | null | undefined;
+    lastAttemptAt?: NativeDate | null | undefined;
+    sentFrom?: string | null | undefined;
+} & mongoose.DefaultTimestampProps> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default phoneVerificationSchema;

package/dist/PhoneVerification.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+/**
+ * Phone Verification Schema
+ * Handles OTP generation, verification, and rate limiting
+ */
+const phoneVerificationSchema = new mongoose_1.default.Schema({
+    userId: {
+        type: mongoose_1.default.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;
+};
+exports.default = phoneVerificationSchema;

package/dist/Review.d.ts

@@ -0,0 +1,38 @@
+import mongoose from 'mongoose';
+export interface IReview {
+    eventId: mongoose.Types.ObjectId;
+    userId: mongoose.Types.ObjectId;
+    ticketId: mongoose.Types.ObjectId;
+    rating: number;
+    title: string;
+    comment: string;
+    reviewContext: {
+        hasCheckedIn: boolean;
+        checkInTime?: Date;
+        ticketTier: string;
+        ticketType: string;
+    };
+    status: 'pending' | 'approved' | 'hidden' | 'flagged';
+    isVisible: boolean;
+    moderationNotes?: string;
+    submittedAt: Date;
+    moderatedAt?: Date;
+    moderatorId?: mongoose.Types.ObjectId;
+    helpfulVotes: number;
+    reportedCount: number;
+    reports: Array<{
+        userId: mongoose.Types.ObjectId;
+        reason: string;
+        reportedAt: Date;
+    }>;
+}
+declare const reviewSchema: mongoose.Schema<IReview, mongoose.Model<IReview, any, any, any, mongoose.Document<unknown, any, IReview, any, {}> & IReview & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IReview, mongoose.Document<unknown, {}, mongoose.FlatRecord<IReview>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<IReview> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default reviewSchema;

package/dist/Review.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const reviewSchema = new mongoose_1.default.Schema({
+    eventId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Event',
+        required: true,
+        index: true
+    },
+    userId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+        index: true
+    },
+    ticketId: {
+        type: mongoose_1.default.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_1.default.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_1.default.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, reason) {
+    // Check if user already reported
+    const existingReport = this.reports.find((report) => report.userId.toString() === userId);
+    if (!existingReport) {
+        this.reports.push({
+            userId: new mongoose_1.default.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, action, notes) {
+    this.moderatorId = new mongoose_1.default.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) {
+    const reviews = await this.find({
+        eventId: new mongoose_1.default.Types.ObjectId(eventId),
+        status: 'approved',
+        isVisible: true
+    });
+    if (reviews.length === 0)
+        return 0;
+    let totalWeightedRating = 0;
+    let totalWeight = 0;
+    reviews.forEach((review) => {
+        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();
+});
+exports.default = reviewSchema;

package/dist/Ticket.d.ts

@@ -6,11 +6,11 @@ declare const ticketSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     eventId: mongoose.Types.ObjectId;
     ticketVariantId: mongoose.Types.ObjectId;
     orderId: mongoose.Types.ObjectId;
+    ticketType: string;
     ticketNumber: string;
     eventTitle: string;
     eventDate: NativeDate;
     eventVenue: string;
-    ticketType: string;
     qrCode: string;
     qrCodeUrl: string;
     checkInStatus: "not_checked_in" | "checked_in";
@@ -28,11 +28,11 @@ declare const ticketSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     eventId: mongoose.Types.ObjectId;
     ticketVariantId: mongoose.Types.ObjectId;
     orderId: mongoose.Types.ObjectId;
+    ticketType: string;
     ticketNumber: string;
     eventTitle: string;
     eventDate: NativeDate;
     eventVenue: string;
-    ticketType: string;
     qrCode: string;
     qrCodeUrl: string;
     checkInStatus: "not_checked_in" | "checked_in";
@@ -50,11 +50,11 @@ declare const ticketSchema: mongoose.Schema<any, mongoose.Model<any, any, any, a
     eventId: mongoose.Types.ObjectId;
     ticketVariantId: mongoose.Types.ObjectId;
     orderId: mongoose.Types.ObjectId;
+    ticketType: string;
     ticketNumber: string;
     eventTitle: string;
     eventDate: NativeDate;
     eventVenue: string;
-    ticketType: string;
     qrCode: string;
     qrCodeUrl: string;
     checkInStatus: "not_checked_in" | "checked_in";