flykup_model_production 1.0.0

package/models/shoppableVideoSave.model.js

@@ -0,0 +1,28 @@
+import mongoose from "mongoose";
+
+const shoppableVideoSaveSchema = new mongoose.Schema(
+  {
+    videoId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "ShoppableVideo",
+      required: true,
+    },
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true,
+    },
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+  }
+);
+
+// Add compound index to ensure a user can only save a video once
+shoppableVideoSaveSchema.index({ videoId: 1, userId: 1 }, { unique: true });
+
+const ShoppableVideoSave = mongoose.model("ShoppableVideoSave", shoppableVideoSaveSchema);
+
+export default ShoppableVideoSave;

package/models/shows.model.js

@@ -0,0 +1,315 @@
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+
+
+// Comment Schema
+const commentSchema = new Schema({
+  user: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "users", // Reference to the User model
+  },
+  text: {
+    type: String,
+  },
+  timeStamp: {
+    type: Date,
+    default: Date.now,
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+const bidSchema = new mongoose.Schema({
+  user: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "users", // Reference to the User model
+    required: true,
+  },
+  amount: {
+    type: Number,
+    required: true,
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+// Auction Schema
+const auctionSchema = new mongoose.Schema(
+  {
+    streamId: {
+      type: String,
+      required: true,
+    },
+    product: {
+      type: String,
+    },
+    auctionType: {
+      type: String, // 'default' or other types
+    },
+    startingBid: {
+      type: Number,
+    },
+    increment: {
+      type: Number,
+      default: 500,
+    },
+    currentHighestBid: {
+      type: Number,
+      default: 0,
+    },
+    nextBid1: {
+      type: Number,
+      default: 0,
+    },
+    nextBid2: {
+      type: Number,
+      default: 0,
+    },
+    highestBidder: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "users", // Store reference to the highest bidder
+      default: null,
+    },
+    bidderWon: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "users", // Store reference to the highest bidder
+      default: null,
+    },
+    bids: [bidSchema], // Array of bids
+    endsAt: {
+      type: Date,
+    },
+    isActive: {
+      type: Boolean,
+      default: true,
+    },
+    uniqueStreamId: {
+      type: String,
+    },
+  },
+  { timestamps: true }
+);
+
+const giveawayProductSchema = new Schema({
+  _id: false,
+  productId: { type: Schema.Types.ObjectId, ref: "productlistings", required: true },
+  productOwnerSellerId: { type: Schema.Types.ObjectId, ref: 'sellers', required: true },
+  productTitle: { type: String },
+
+  // BGA Integration Fields
+  giveawayObjectId: { type: Schema.Types.ObjectId, required: true, index: true },
+  giveawayStatus: {
+    type: String,
+    enum: ['preparing', 'ready', 'active', 'ended', 'failed'],
+    default: 'preparing'
+  },
+  activatedAt: { type: Date, default: null },
+  createdAt: { type: Date, default: Date.now }
+});
+
+// Show Schema
+const showSchema = new Schema(
+  {
+    // === MODIFIED START: Host Information ===
+    sellerId: {  // <--- REMOVE or comment out this line
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "sellers",
+    },
+    host: { // New field for the host (Seller or Dropshipper)
+      type: mongoose.Schema.Types.ObjectId,
+      required: true,
+      refPath: 'hostModel' // Dynamic reference
+    },
+    hostModel: { // New field to define the type of host
+      type: String,
+      required: true,
+      enum: ['sellers', 'dropshippers'] // Allowed host types
+    },
+    // === MODIFIED END: Host Information ===
+
+    title: {
+      type: String,
+      required: true,
+    },
+    date: {
+      type: Date,
+    },
+    time: {
+      type: String,
+    },
+    scheduledAt: {
+      type: Date,
+      index: true // Add index for better query performance
+    },
+    category: {
+      type: String,
+    },
+    subCategory: {
+      type: String,
+      default: '',
+    },
+    liveStreamId: { type: String, default: null },
+    streamName: {
+      type: String,
+      default: ''
+    },
+    tags: {
+      type: [String],
+      default: [],
+    },
+
+    thumbnailImage: {
+      type: String, // URL or file path
+      default: null,
+    },
+    previewVideo: {
+      type: String, // URL or file path
+      default: null,
+    },
+    language: {
+      type: String,
+    },
+    isLive: {
+      type: Boolean,
+      default: false,
+    },
+    streamUrl: {
+      type: String, // URL for the live stream
+      default: null,
+    },
+    showStatus: {
+      type: String,
+      enum: ['created', 'live', 'cancelled', 'ended'],
+      default: 'created'
+    },
+    comments: [commentSchema], // Array of comments
+    likes: {
+      type: Number,
+      default: 0,
+    },
+    likedBy: {
+      type: [mongoose.Schema.Types.ObjectId],
+      ref: 'users',
+      default: [],
+    },
+    // auctions: [auctionSchema], // Array of auctions
+    currentAuction: auctionSchema,
+    buyNowProducts: {
+      type: [
+        {
+          _id: false,
+          productId: { type: Schema.Types.ObjectId, ref: "productlistings" },
+          // --- ADDED productOwnerSellerId ---
+          productOwnerSellerId: { type: Schema.Types.ObjectId, ref: 'sellers', required: true },
+          productPrice: { type: Number, min: 0, default: null }, // Price set by host for this show
+        },
+      ],
+      default: [],
+    },
+    auctionProducts: {
+      type: [
+        {
+          _id: false,
+          productId: { type: Schema.Types.ObjectId, ref: "productlistings" },
+          // --- ADDED productOwnerSellerId ---
+          productOwnerSellerId: { type: Schema.Types.ObjectId, ref: 'sellers', required: true },
+          startingPrice: { type: Number, min: 0, default: null },
+          reservedPrice: { type: Number, min: 0, default: null },
+          isAuctionEnded: {
+            type: Boolean,
+            default: false
+          },
+          streamId: {
+            type: String,
+          },
+          // product: {
+          //     type: String,
+          // },
+          auctionType: {
+            type: String, // 'default' or other types
+          },
+          startingBid: {
+            type: Number,
+          },
+          increment: {
+            type: Number,
+            default: 5,
+          },
+          currentHighestBid: {
+            type: Number,
+            default: 0,
+          },
+          nextBid1: {
+            type: Number,
+            default: 0,
+          },
+          nextBid2: {
+            type: Number,
+            default: 0,
+          },
+          highestBidder: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: "users", // Store reference to the highest bidder
+            default: null,
+          },
+          bidderWon: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: "users", // Store reference to the highest bidder
+            default: null,
+          },
+          bids: [bidSchema], // Array of bids
+          endsAt: {
+            type: Date,
+          },
+          isActive: {
+            type: Boolean,
+            default: true,
+          },
+          uniqueStreamId: {
+            type: String,
+          },
+          auctionNumber: {  // <-- New field in auctionProducts sub-schema
+            type: Number,
+          }
+        },
+      ],
+      default: [],
+    },
+
+    giveawayProducts: {
+      type: [giveawayProductSchema],
+      default: []
+    },
+    notes: {
+      type: String,
+      default: ''
+    },
+    // giveaways: [giveawaySchema], // Array of giveaways
+  },
+  { timestamps: true }
+);
+
+showSchema.pre('save', function (next) {
+  const doc = this;
+
+  // Set liveDrop based on product types
+  const hasBuyNow = doc.buyNowProducts && doc.buyNowProducts.length > 0;
+  const hasAuction = doc.auctionProducts && doc.auctionProducts.length > 0;
+  const hasGiveaway = doc.giveawayProducts && doc.giveawayProducts.length > 0;
+  doc.liveDrop = hasBuyNow && hasAuction && hasGiveaway;
+
+  // Ensure coHost is null if hasCoHost is false
+  if (!doc.hasCoHost) {
+    doc.coHost = null;
+  }
+
+  next();
+});
+
+const Show = mongoose.model("shows", showSchema);
+
+export default Show;

package/models/stock.model.js

@@ -0,0 +1,128 @@
+import mongoose from "mongoose";
+const { Schema, model } = mongoose;
+
+const StockSchema = new Schema(
+    {
+        sellerId: {
+            type: Schema.Types.ObjectId,
+            ref: "sellers",
+        },
+        productListingId: {
+            type: Schema.Types.ObjectId,
+            ref: "productlistings",
+        },
+        title: String,
+        quantity: {
+            type: Number,
+            min: 0,
+            default: null,
+        },
+        images: [
+            {
+                key: { type: String, maxLength: 255, default: null },
+                blobName: { type: String, maxLength: 255, default: null },
+                azureUrl: { type: String, maxLength: 1024, default: null },
+            },
+        ],
+        mfgDate: {
+            type: String,
+            default: null,
+        },
+        expDate: {
+            type: String,
+            default: null,
+        },
+    },
+    { timestamps: true }
+);
+
+const Stock = model("stocks", StockSchema);
+
+export default Stock;
+
+
+// models/Stock.js
+// // models/Stock.js
+// import mongoose from "mongoose";
+// const { Schema, model } = mongoose;
+
+// const StockSchema = new Schema(
+//   {
+//     sellerId: {
+//       type: Schema.Types.ObjectId,
+//       ref: "sellers",
+//     },
+//     productListingId: {
+//       type: Schema.Types.ObjectId,
+//       ref: "productlistings",
+//     },
+//     title: String,
+//     quantity: {
+//       type: Number,
+//       min: 0,
+//       default: 0,
+//     },
+//     // Track reservations for current and upcoming flash sales
+//     flashSaleReservations: [{
+//       flashSaleId: {
+//         type: Schema.Types.ObjectId,
+//         ref: "FlashSale",
+//         required: true
+//       },
+//       productId: {
+//         type: Schema.Types.ObjectId,
+//         ref: "productlistings",
+//         required: true
+//       },
+//       quantity: {
+//         type: Number,
+//         min: 0,
+//         default: 0
+//       },
+//       status: {
+//         type: String,
+//         enum: ['reserved', 'active', 'released', 'sold', 'partially_sold'],
+//         default: 'reserved'
+//       },
+//       reservedAt: {
+//         type: Date,
+//         default: Date.now
+//       },
+//       releasedAt: Date,
+//       soldQuantity: {
+//         type: Number,
+//         default: 0
+//       }
+//     }],
+//     // Total reserved quantity (calculated field)
+//     totalReserved: {
+//       type: Number,
+//       min: 0,
+//       default: 0
+//     }
+//   },
+//   { timestamps: true }
+// );
+
+// // Update totalReserved when flashSaleReservations change
+// StockSchema.pre('save', function(next) {
+//   if (this.isModified('flashSaleReservations')) {
+//     this.totalReserved = this.flashSaleReservations.reduce((total, reservation) => {
+//       return total + (reservation.status === 'reserved' || reservation.status === 'active' ? reservation.quantity : 0);
+//     }, 0);
+//   }
+//   next();
+// });
+
+// // Virtual for available quantity (total - reserved)
+// StockSchema.virtual('availableQuantity').get(function() {
+//   return Math.max(0, this.quantity - this.totalReserved);
+// });
+
+// // Ensure virtuals are included in toJSON output
+// StockSchema.set('toJSON', { virtuals: true });
+// StockSchema.set('toObject', { virtuals: true });
+
+// const Stock = model("stocks", StockSchema);
+
+// export default Stock;

package/models/ticket.model.js

@@ -0,0 +1,115 @@
+// models/Ticket.js
+import mongoose from 'mongoose';
+
+const replySchema = new mongoose.Schema({
+  message: {
+    type: String,
+    required: true,
+  },
+  repliedBy: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    required: true,
+  },
+  repliedByRole: {
+    type: String,
+    enum: ['Admin', 'Seller'],
+    required: true,
+  },
+  repliedAt: {
+    type: Date,
+    default: Date.now,
+  },
+  attachments: [
+    {
+      type: String, // URLs or file paths for reply attachments
+      required: false,
+    },
+  ],
+});
+
+const ticketSchema = new mongoose.Schema(
+  {
+    ticketId: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    raisedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users',
+      required: true,
+    },
+    raisedByRole: {
+      type: String,
+      enum: ['User', 'Seller'],
+      required: true,
+    },
+
+     // NEW: Reference to the order this ticket is related to
+    orderId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Order', // Assuming your order model is named 'orders'
+      required: false,
+    },
+    // NEW: Reference to the seller user associated with the order
+    sellerUserId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users',
+      required: false,
+    },
+    ticketPurposeId: {
+      type: String,
+      required: true,
+    },
+    ticketPurposePage: {
+      type: String,
+      required: true,
+    },
+    attachments: [
+      {
+        type: String, // Assuming attachments are stored as URLs or file paths
+        required: false,
+      },
+    ],
+    issueType: {
+      type: String,
+      required: true,
+    },
+    description: {
+      type: String,
+      required: true,
+    },
+    status: {
+      type: String,
+      enum: ['Open', 'In Progress', 'Resolved', 'Closed'],
+      default: 'Open',
+    },
+    // New reply fields
+    sellerReply: {
+      type: replySchema,
+      required: false,
+    },
+    adminReply: {
+      type: replySchema,
+      required: false,
+    },
+    // Track multiple replies (conversation history)
+    replies: [replySchema],
+    // Last updated by (for tracking purposes)
+    lastUpdatedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users',
+      required: false,
+    },
+    lastUpdatedByRole: {
+      type: String,
+      enum: ['User', 'Seller', 'Admin'],
+      required: false,
+    },
+  },
+  { timestamps: true }
+);
+
+const Ticket = mongoose.model('Ticket', ticketSchema);
+export default Ticket;