flykup_model_production 1.0.10 → 1.0.11

package/index.js

@@ -33,6 +33,7 @@ import SellerDraft from './models/sellerDraft.model.js';
 import AadhaarVerification from './models/AadhaarVerification.js';
 import BankVerification from './models/BankVerification.js';
 import GSTVerification from './models/GSTVerification.js';
+import OrderPayment from './models/orderPayment.model.js';
 let initialized = false;
 
 export async function initializeSharedModels({ token, dbUri }) {
@@ -97,7 +98,7 @@ export const SellerDraftModel = createModelProxy(SellerDraft);
 export const AadhaarVerificationModel = createModelProxy(AadhaarVerification);
 export const BankVerificationModel = createModelProxy(BankVerification);
 export const GSTVerificationModel = createModelProxy(GSTVerification);
-
+export const OrderPaymentModel = createModelProxy(OrderPayment)
 
 export {
   AdminModel as Admin,
@@ -134,5 +135,6 @@ export {
   SellerDraftModel as SellerDraft,
   AadhaarVerificationModel as AadhaarVerification,
   BankVerificationModel as BankVerification,
-  GSTVerificationModel as GSTVerification
+  GSTVerificationModel as GSTVerification,
+  OrderPaymentModel as OrderPayment
 };

package/models/BankVerification.js

@@ -8,6 +8,16 @@ const bankVerificationSchema = new mongoose.Schema({
     required: true,
     unique: true, // Ensures only one bank verification per user
     index: true
+  },
+   sellerId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'sellers', 
+    
+  },
+  role: {
+    type: String,
+    enum: ['user', 'seller', 'admin'], 
+   
   },
   accountNumber: {
     type: String,

package/models/LiveStreamInteraction.model.js

@@ -69,6 +69,15 @@ const liveStreamInteractionSchema = new mongoose.Schema({
         type: mongoose.Schema.Types.ObjectId,
         ref: 'productlistings'
     }],
+    auctionBids: [{
+    productId: { type: mongoose.Schema.Types.ObjectId, ref: 'productlistings' },
+    bidAmount: { type: Number, required: true },
+    bidTime: { type: Date, default: Date.now }
+}],
+giveawayEntries: [{
+    productId: { type: mongoose.Schema.Types.ObjectId, ref: 'productlistings' },
+    entryTime: { type: Date, default: Date.now }
+}]
 }, { 
     timestamps: true 
 });

package/models/ProductInteraction.model.js

@@ -1,34 +1,53 @@
 import mongoose, { Schema, model } from 'mongoose';
 
 const productInteractionSchema = new mongoose.Schema({
-    product: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true },
-    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', index: true },
-    seller: { type: mongoose.Schema.Types.ObjectId, ref: 'Seller', required: true },
-    location: {
-        city: String,
-        region: String,
-        country: String
-    },
-    // --- NEW FIELD ---
-    platform: { type: String, enum: ['web', 'mobile', 'unknown'], default: 'mobile' }, 
-    device: { type: String, enum: ['mobile', 'desktop', 'tablet', 'other'] },
-    browser: String,
-    os: String,
-    ip: { type: String, required: true },
-    isIndianRegion: { type: Boolean, default: false },
-     rating: {
-        type: Number,
-        min: 1,
-        max: 5,
-        validate: {
-            validator: Number.isInteger,
-            message: '{VALUE} is not an integer value'
-        }
-    },
-    review: {
-        type: String,
-        maxlength: 500
+  product: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true },
+  user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', index: true },
+  seller: { type: mongoose.Schema.Types.ObjectId, ref: 'Seller', required: true },
+  location: {
+    city: String,
+    region: String,
+    country: String
+  },
+  platform: { type: String, enum: ['web', 'mobile', 'unknown'], default: 'mobile' },
+  device: { type: String, enum: ['mobile', 'desktop', 'tablet', 'other'] },
+  browser: String,
+  os: String,
+  ip: { type: String, required: true },
+  isIndianRegion: { type: Boolean, default: false },
+  rating: {
+    type: Number,
+    min: 1,
+    max: 5,
+    validate: {
+      validator: Number.isInteger,
+      message: '{VALUE} is not an integer value'
     }
+  },
+  review: {
+    type: String,
+    maxlength: 500
+  },
+  viewCount: { type: Number, default: 1 },
+  // NEW: Trust signals tracking
+  trustSignals: {
+    reviewViews: { type: Number, default: 0 }, // How many times user viewed reviews
+    reviewViewDuration: { type: Number, default: 0 }, // Total time spent on reviews (seconds)
+    comparisonViews: { type: Number, default: 0 }, // How many times user compared with other products
+    priceCheckCount: { type: Number, default: 0 }, // How many times user checked pricing
+    lastTrustSignalAt: { type: Date } // When the last trust signal was recorded
+  },
+  // NEW: Engagement status for sellers
+  engagementStatus: {
+    type: String,
+    enum: ['new', 'interested', 'hesitant', 'contacted', 'converted'],
+    default: 'new'
+  },
+  sellerNotes: [{
+    note: String,
+    createdAt: { type: Date, default: Date.now },
+    updatedAt: { type: Date, default: Date.now }
+  }]
 }, { timestamps: true });
 
 // Ensures a user's view is counted only once per product
@@ -40,3 +59,50 @@ productInteractionSchema.index({ createdAt: -1 });
 // Safe export to prevent OverwriteModelError
 const ProductInteraction = mongoose.models.ProductInteraction || mongoose.model('ProductInteraction', productInteractionSchema);
 export default ProductInteraction;
+
+
+
+
+// import mongoose, { Schema, model } from 'mongoose';
+
+// const productInteractionSchema = new mongoose.Schema({
+//     product: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true },
+//     user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', index: true },
+//     seller: { type: mongoose.Schema.Types.ObjectId, ref: 'Seller', required: true },
+//     location: {
+//         city: String,
+//         region: String,
+//         country: String
+//     },
+//     // --- NEW FIELD ---
+//     platform: { type: String, enum: ['web', 'mobile', 'unknown'], default: 'mobile' }, 
+//     device: { type: String, enum: ['mobile', 'desktop', 'tablet', 'other'] },
+//     browser: String,
+//     os: String,
+//     ip: { type: String, required: true },
+//     isIndianRegion: { type: Boolean, default: false },
+//      rating: {
+//         type: Number,
+//         min: 1,
+//         max: 5,
+//         validate: {
+//             validator: Number.isInteger,
+//             message: '{VALUE} is not an integer value'
+//         }
+//     },
+//     review: {
+//         type: String,
+//         maxlength: 500
+//     },
+//     viewCount: { type: Number, default: 1 }
+// }, { timestamps: true });
+
+// // Ensures a user's view is counted only once per product
+// productInteractionSchema.index({ product: 1, user: 1 }, { unique: true, partialFilterExpression: { user: { $exists: true } } });
+
+// // Additional indexes for performance
+// productInteractionSchema.index({ createdAt: -1 });
+
+// // Safe export to prevent OverwriteModelError
+// const ProductInteraction = mongoose.models.ProductInteraction || mongoose.model('ProductInteraction', productInteractionSchema);
+// export default ProductInteraction;

package/models/ShoppableInteraction.model.js

@@ -61,7 +61,22 @@ const shoppableVideoInteractionSchema = new mongoose.Schema({
     productsClicked: [{ // Unique list of products clicked by this user for this video
         type: mongoose.Schema.Types.ObjectId,
         ref: 'productlistings'
-    }]
+    }],
+    maxSecondReached: { 
+    type: Number, 
+    default: 0 
+  },
+  rewatchCount: {
+    type: Number,
+    default: 0
+  },
+  watchSessions: [{
+    startedAt: Date,
+    endedAt: Date,
+    duration: Number,
+    completionPercentage: Number,
+    maxSecond: Number
+  }],
 }, { 
     timestamps: true 
 });
@@ -71,6 +86,9 @@ shoppableVideoInteractionSchema.index({ video: 1, user: 1 }, {
     unique: true, 
     partialFilterExpression: { user: { $exists: true } } 
 });
+shoppableVideoInteractionSchema.index({ video: 1, maxSecondReached: 1 });
+shoppableVideoInteractionSchema.index({ video: 1, rewatchCount: 1 });
+shoppableVideoInteractionSchema.index({ host: 1, user: 1 });
 
 // Ensures a unique interaction record per anonymous session per video.
 shoppableVideoInteractionSchema.index({ video: 1, sessionIdentifier: 1 }, { 

package/models/chat.model.js

@@ -191,6 +191,13 @@ const ChatMessageSchema = new mongoose.Schema({
     required: true
   },
 
+  source: {
+  type: String,
+  enum: ['chat', 'product', 'shoppable', 'liveVideo'],
+  default: 'chat'
+},
+
+
   // Message content
   messageType: {
     type: String,

package/models/notification.model.js

@@ -17,6 +17,10 @@ const notificationSchema = new mongoose.Schema(
         "return_status",
         'new_video',
         "new_product",
+        'admin_broadcast',
+        'seller_broadcast',
+        'live_stream_start',
+        'seller_order_update'
       ],
       required: true,
     },

package/models/order.modal.js

@@ -1,5 +1,6 @@
+
 // order.modal.js
-import mongoose, { Schema, model } from 'mongoose';
+import mongoose from 'mongoose';
 import { nanoid } from 'nanoid';
 
 const orderSchema = new mongoose.Schema(
@@ -8,7 +9,7 @@ const orderSchema = new mongoose.Schema(
       type: String,
       required: true,
       unique: true,
-      default: () => `ORD-${nanoid(8)}`
+      default: () => `FLY-ORD-${nanoid(8)}`
     },
     userId: {
       type: mongoose.Schema.Types.ObjectId,
@@ -48,7 +49,15 @@ const orderSchema = new mongoose.Schema(
         type: String,
         enum: ['CGST+SGST', 'IGST',"NON-GST"],
         required: true
-      }
+      },
+      isFlashSale: {
+      type: Boolean,
+      default: false
+    },
+    flashPrice: {
+      type: Number,
+      default: null // Store the specific flash price used for this item
+    }
     }],
     totalBaseAmount: {
       type: Number,
@@ -100,6 +109,77 @@ const orderSchema = new mongoose.Schema(
         default: null
      }
    },
+    logisticsDetails: {
+      shipmentMethod: {
+        type: String,
+        enum: ['self_shipment', 'flykup_logistics'],
+        default: 'flykup_logistics'
+      },
+      awbNumber: String,
+      carrier: String,
+      carrierId: String,
+      trackingNumber: String,
+      trackingUrl: String,
+      expectedDeliveryDate: Date,
+      shipmentBookedAt: Date,
+      logisticsResponse: mongoose.Schema.Types.Mixed,
+     shipmentBookingStatus: {
+        type: String,
+        enum: ['pending', 'booked', 'failed', 'cancelled', 'cancellation_failed'], // Add the new value here
+        default: 'pending'
+      },
+      shipmentBookingError: String,
+      multipleSellers: {
+        type: Boolean,
+        default: false
+      },
+      selectedCourier: {
+        courierId: String,
+        courierName: String,
+        deliveryCharges: Number,
+        estimatedDays: Number,
+        deliveryDate: String
+      },
+      cancellationAttemptedAt: Date,
+      cancellationResult: {
+        success: Boolean,
+        message: String,
+        error: String,
+        responseData: mongoose.Schema.Types.Mixed
+      },
+      cancellationEligibility: {
+        eligible: Boolean,
+        reason: String
+      },
+            tracking: {
+    lastSyncedAt: Date,
+    currentStatus: String,
+    statusCode: String,
+    progressPercentage: Number,
+    currentLocation: String,
+    estimatedDelivery: Date,
+    trackingTimeline: [{
+      date: Date,
+      status: String,
+      location: String,
+      icon: String
+    }]
+  },
+    },
+    packageDetails: {
+      totalWeight: Number,
+      weightUnit: {
+        type: String,
+        default: 'grams'
+      },
+      dimensions: {
+        length: Number,
+        width: Number,
+        height: Number
+      },
+ 
+      volumetricWeight: Number
+    },
     pickupAddresses: [{
       sellerUserId: {
         type: mongoose.Schema.Types.ObjectId,
@@ -136,7 +216,7 @@ const orderSchema = new mongoose.Schema(
     }],
     paymentMethod: {
       type: String,
-      enum: ['CARD', 'UPI', 'NETBANKING', 'WALLET', 'COD', "PENDING_PAYMENT", "CASHFREE", "Online"],
+      enum: ['CARD', 'UPI', 'NETBANKING', 'WALLET', 'COD', "PENDING_PAYMENT", "CASHFREE","RAZORPAY", "Online"],
       required: true
     },
     paymentStatus: {
@@ -168,7 +248,7 @@ const orderSchema = new mongoose.Schema(
     },
     sourceType: {
       type: String,
-      enum: ['static', 'shoppable_video', 'livestream', 'auction'],
+      enum: ['static', 'shoppable_video', 'livestream', 'auction', 'flash_sale', 'giveaway'],
       required: true
     },
     sourceRefId: String,
@@ -254,6 +334,19 @@ cancelSource: {
   enum: ['user', 'seller', 'system'],
   default: 'user'
 },
+  flashSaleItems: [{
+    productId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'productlistings'
+    },
+    flashSaleId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'FlashSale'
+    },
+    quantity: Number,
+    flashPrice: Number,
+    originalPrice: Number
+  }],
 payment: {
   type: mongoose.Schema.Types.ObjectId,
   ref: 'orderPayment'
@@ -273,10 +366,12 @@ payment: {
   },
   invoiceError: String
   },
+ 
   { timestamps: true }
 );
 
 
 
+
 const Order = mongoose.models.Order || mongoose.model('Order', orderSchema);
 export default Order;

package/models/orderPayment.model.js

@@ -0,0 +1,91 @@
+import mongoose from 'mongoose';
+
+const paymentSchema = new mongoose.Schema({
+  orderId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Order',
+    required: true
+  },
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    required: true
+  },
+  paymentGateway: {
+    type: String,
+    enum: ['RAZORPAY', 'CASHFREE'],
+    required: true
+  },
+
+  // Razorpay-specific fields
+  razorpayOrderId: {
+    type: String,
+    // ✅ This field is now required only if the gateway is RAZORPAY
+    required: function() {
+      return this.paymentGateway === 'RAZORPAY';
+    }
+  },
+  razorpayPaymentId: {
+    type: String,
+    default: null
+  },
+
+  // Cashfree-specific fields
+  cfPaymentSessionId: {
+    type: String,
+    // ✅ This field is now required only if the gateway is CASHFREE
+    required: function() {
+      return this.paymentGateway === 'CASHFREE';
+    }
+  },
+  cfOrderId: {
+    type: String,
+    // ✅ This field is now required only if the gateway is CASHFREE
+    required: function() {
+      return this.paymentGateway === 'CASHFREE';
+    }
+  },
+
+  amount: {
+    type: Number,
+    required: true
+  },
+  currency: {
+    type: String,
+    default: 'INR'
+  },
+  status: {
+    type: String,
+    enum: ['PENDING', 'SUCCESS', 'FAILED', 'REFUNDED'],
+    default: 'PENDING'
+  },
+  paymentMethod: String,
+  transactionTime: Date,
+  sellerPayments: [{
+    sellerId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users',
+      required: true
+    },
+    amount: Number,
+    settlementStatus: {
+      type: String,
+      enum: ['PENDING', 'SETTLED','FAILED'],
+      default: 'PENDING'
+    }
+  }]
+}, {
+  timestamps: true
+});
+
+// Create indexes for better performance
+paymentSchema.index({ razorpayOrderId: 1 });
+paymentSchema.index({ cfOrderId: 1 });
+paymentSchema.index({ orderId: 1 });
+
+// ❌ The pre-save middleware is no longer needed and should be removed.
+
+const OrderPayment =
+  mongoose.models.OrderPayment || mongoose.model('orderPayment', paymentSchema);
+
+export default OrderPayment;

package/models/productListing.model.js

@@ -1,3 +1,7 @@
+
+
+
+
 // backend/models/ProductListing.js (or similar path)
 import mongoose from "mongoose";
 const { Schema } = mongoose;
@@ -8,6 +12,20 @@ const ProductListingSchema = new Schema(
     stockId: { type: Schema.Types.ObjectId, ref: "stocks" },
     title: String,
     description: String,
+      flashSale: {
+    isActive: { type: Boolean, default: false },
+    flashSaleId: { type: mongoose.Schema.Types.ObjectId, ref: 'FlashSale' },
+    flashPrice: { type: Number, default: 0 },
+    flashStock: { type: Number, default: 0 },
+    originalPrice: { type: Number, default: 0 },
+    endsAt: { type: Date, default: null },
+    startsAt: { type: Date, default: null }
+  },
+    sku: {
+      type: String,
+      required: true,
+      index: true
+    },
     images: [
       {
         key: { type: String, maxLength: 255, default: null },
@@ -36,7 +54,22 @@ const ProductListingSchema = new Schema(
       min: 0,
       default: null,
     },
-
+     logisticsType: {
+      type: String,
+      enum: ["flykupLogistics", "selfShipment"],
+      default: null,
+    },
+    deliveryCharge: {
+      type: Number,
+      min: 0,
+      default: null,
+    },
+    estimatedDeliveryDate: {
+      type: Number, // Change from Date to Number
+      min: 0,
+      default: null,
+    },
+  
     // --- ADDED/UPDATED FIELDS FROM FRONTEND ---
     brand: { type: String, default: null }, // ADDED
     manufacturer: String,
@@ -123,10 +156,187 @@ totalReviews: { type: Number, default: 0 }
   },
   { timestamps: true }
 );
+ProductListingSchema.index({ title: 'text', description: 'text', category: 'text' });
 
-// Optional: Ensure strict mode is not preventing fields if you intended flexibility (default is true)
-// ProductListingSchema.set('strict', false); // Use with caution
 
 // Safe export to prevent OverwriteModelError
 const ProductListing = mongoose.models.productlistings || mongoose.model("productlistings", ProductListingSchema);
 export default ProductListing;
+
+
+
+
+
+
+
+
+
+
+
+// // backend/models/ProductListing.js (or similar path)
+// import mongoose from "mongoose";
+// const { Schema } = mongoose;
+
+// const ProductListingSchema = new Schema(
+//   {
+//     sellerId: { type: Schema.Types.ObjectId, ref: "sellers" },
+//     stockId: { type: Schema.Types.ObjectId, ref: "stocks" },
+//     title: String,
+//     description: String,
+//       flashSale: {
+//     isActive: { type: Boolean, default: false },
+//     flashSaleId: { type: mongoose.Schema.Types.ObjectId, ref: 'FlashSale' },
+//     flashPrice: { type: Number, default: 0 },
+//     flashStock: { type: Number, default: 0 },
+//     originalPrice: { type: Number, default: 0 },
+//     endsAt: { type: Date, default: null },
+//     startsAt: { type: Date, default: null }
+//   },
+  
+// //new fields added 
+
+// returnPolicy: {
+//       hasReturn: { type: Boolean, default: false },
+//       returnType: { 
+//         type: [String], 
+//         enum: ['refund', 'replacement'],
+//         default: []
+//       },
+//       returnDays: { type: Number, min: 0, default: null },
+//       terms: [String] // Keep existing terms for backward compatibility
+//     },
+//     sku: {
+//       type: String,
+//       required: true,
+//       match: [/^[A-Za-z0-9-]{6,}$/, 'SKU must be at least 6 alphanumeric characters']
+//     },
+// // ----------end of new fields added
+//     images: [
+//       {
+//         key: { type: String, maxLength: 255, default: null },
+//       }
+//     ],
+//     category: String,
+//     subcategory: String,
+//     hsnNo: String,
+//     MRP: {
+//       type: Number,
+//       min: 0,
+//       default: null,
+//     },
+//     productPrice: {
+//       type: Number,
+//       min: 0,
+//       default: null,
+//     },
+//     startingPrice: {
+//       type: Number,
+//       min: 0,
+//       default: null,
+//     },
+//     reservedPrice: {
+//       type: Number,
+//       min: 0,
+//       default: null,
+//     },
+
+//     // --- ADDED/UPDATED FIELDS FROM FRONTEND ---
+//     brand: { type: String, default: null }, // ADDED
+//     manufacturer: String,
+//     manufacturerAddress: String, // ADDED in frontend, already exists here
+//     countryOfOrigin: String,
+//     netQuantity: { type: String, default: null }, // ADDED (String to accommodate units like '500g')
+//     packagingType: { type: String, default: null }, // ADDED
+//     weight: { // For shipping calculations
+//       value: { type: Number, default: null },
+//       unit: { type: String, default: null },
+//     },
+//     dimensions: { // For shipping calculations
+//       length: { type: Number, default: null },
+//       width: { type: Number, default: null },
+//       height: { type: Number, default: null },
+//     },
+//     expiryDate: { type: Date, default: null }, // ADDED in frontend, already exists here (changed to allow null)
+//     shelfLife: { type: String, default: null }, // ADDED in frontend, already exists here (changed to allow null)
+//     batchNumber: { type: String, default: null }, // ADDED in frontend, already exists here (changed to allow null)
+//     gstRate: { type: Number, default: null }, // Changed to allow null if needed
+//     sellerName: String,
+//     sellerContact: { type: String, default: null }, // ADDED
+//     sellerGSTIN: { type: String, default: null }, // ADDED
+//     returnPolicy: [String],
+//     warranty: {
+//       hasWarranty: { type: Boolean, default: false }, // Default added
+//       duration: { type: String, default: null }, // Default added
+//     },
+//     fssaiLicenseNo: { type: String, default: null }, // ADDED in frontend, already exists here (changed to allow null)
+//     bisCertification: { type: String, default: null }, // ADDED in frontend, already exists here (changed to allow null)
+//     importerName: { type: String, default: null }, // Default added
+//     importerAddress: { type: String, default: null }, // Default added
+//     importerGSTIN: { type: String, default: null }, // Default added
+//     eWasteCompliance: { type: Boolean, default: false }, // Default added
+//     recyclablePackaging: { type: Boolean, default: false }, // Default added
+//     hazardousMaterials: { type: String, default: null }, // Default added
+//     allowDropshipping: {
+//       type: Boolean,
+//       default: false,
+//       index: true,
+//     },
+//     commissionRate: {
+//       type: Number,
+//       min: [0, 'Commission rate cannot be negative.'],
+//       // max: [100, 'Commission rate cannot exceed 100%.'], // Max was 25, changed to 100 based on frontend
+//       max: [100, 'Commission rate cannot exceed 100%.'],
+//       default: null,
+//       // Removed Mongoose-level required validation dependent on allowDropshipping
+//       // Let application logic handle this if needed, or adjust validator
+//       // required: [
+//       //   function () { return this.allowDropshipping === true; },
+//       //   'Commission rate is required when allowing dropshipping.'
+//       // ],
+//       // validate: { ... } // Keep or remove validation as needed
+//     },
+//     hasReturn: {
+//   type: Boolean,
+//   default: false
+// },
+// returnDays: {
+//   type: Number,
+//   min: 0,
+//   default: null
+// },
+// size: {
+//   type: String,
+//   default: null
+// },
+//     isActive: {
+//       type: Boolean,
+//       default: true,
+//     },ratingSummary: {
+//     averageRating: { type: Number, default: 0 },
+//     totalRatings: { type: Number, default: 0 },
+//     ratingDistribution: {
+//         1: { type: Number, default: 0 },
+//         2: { type: Number, default: 0 },
+//         3: { type: Number, default: 0 },
+//         4: { type: Number, default: 0 },
+//         5: { type: Number, default: 0 }
+//     }
+// },
+// totalReviews: { type: Number, default: 0 }
+//   },
+
+
+  
+//   { timestamps: true }
+// );
+// ProductListingSchema.index({ title: 'text', description: 'text', category: 'text' });
+// ProductListingSchema.index({ sellerId: 1, sku: 1 }, { unique: true });
+
+// // Safe export to prevent OverwriteModelError
+// const ProductListing = mongoose.models.productlistings || mongoose.model("productlistings", ProductListingSchema);
+// export default ProductListing;
+
+
+
+
+

package/models/seller.model.js

@@ -113,6 +113,8 @@ const SellerSchema = new mongoose.Schema(
     fssaiCertificateFileName: {
       type: String
     },
+         bisCertificateFileName: { type: String, default: null },       // New BIS certificate
+  qualityCertificateFileName: { type: String, default: null },   // New Quality certificate
     productCatalog: {
       link: { type: String },
       file: { type: String },      // for old sellers
@@ -289,7 +291,8 @@ const SellerSchema = new mongoose.Schema(
         start: { type: String, default: '09:00' },
         end: { type: String, default: '18:00' }
       }
-    }
+    },
+    
   },
   { timestamps: true, strict: true }
 );
@@ -308,5 +311,6 @@ SellerSchema.index({
   },
   name: "seller_text_index"
 });
+
 const Seller = mongoose.models.sellers || mongoose.model("sellers", SellerSchema);
 export default Seller;

package/models/shoppableVideo.model.js

@@ -37,8 +37,8 @@ const ShoppableVideoSchema = new Schema(
       required: false,
       trim: true,
     },
-    category: { type: String, required: true, trim: true },
-    subcategory: { type: String, required: true, trim: true },
+    category: { type: String, required: false, trim: false},
+    subcategory: { type: String, required: false, trim: false },
     // thumbnailURL might be set initially or updated by the processing service
    isThumbnailEnabled: {
       type: Boolean,
@@ -48,7 +48,7 @@ const ShoppableVideoSchema = new Schema(
       type: String,
       default: null
     },
-    isProductsAvailable : { type : Boolean, required : true, default : true },
+    isProductsAvailable : { type : Boolean, required : true, default : false },
     productsListed: {
       type: [
         {
@@ -167,11 +167,31 @@ const ShoppableVideoSchema = new Schema(
         type: Number,
         default: 0
     },
-    isEligibleToPlay : {
-      type: Boolean,
-      default: false, // Default to true, can be set to false if video is not eligible for playback
-      index: true // Index for quick lookups
-    }
+    // Admin blocking fields
+isBlocked: {
+  type: Boolean,
+  default: false,
+  index: true // For efficient queries of blocked videos
+},
+blockedBy: {
+  type: Schema.Types.ObjectId,
+  ref: 'Admin',
+  default: null
+},
+blockReason: {
+  type: String,
+  default: null,
+  trim: true
+},
+blockedAt: {
+  type: Date,
+  default: null
+},
+isEligibleToPlay: {
+  type: Boolean,
+  default: false, // Default to true, can be set to false if video is not eligible for playback
+  index: true // Index for quick lookups
+}
   },
   { timestamps: true }
 );

package/models/shows.model.js

@@ -1,99 +1,6 @@
 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 },
@@ -119,22 +26,22 @@ const giveawayProductSchema = new Schema({
 // 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)
+
+      sellerId: {  // <--- REMOVE or comment out this line
+            type: mongoose.Schema.Types.ObjectId,
+            ref: "sellers",
+        },
+    // === Host Information ===
+    host: { // Host (Seller or Dropshipper)
       type: mongoose.Schema.Types.ObjectId,
       required: true,
       refPath: 'hostModel' // Dynamic reference
     },
-    hostModel: { // New field to define the type of host
+    hostModel: { // Type of host
       type: String,
       required: true,
       enum: ['sellers', 'dropshippers'] // Allowed host types
     },
-    // === MODIFIED END: Host Information ===
 
     title: {
       type: String,
@@ -191,7 +98,6 @@ const showSchema = new Schema(
       enum: ['created', 'live', 'cancelled', 'ended'],
       default: 'created'
     },
-    comments: [commentSchema], // Array of comments
     likes: {
       type: Number,
       default: 0,
@@ -201,14 +107,12 @@ const showSchema = new Schema(
       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
         },
@@ -220,64 +124,10 @@ const showSchema = new Schema(
         {
           _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
+          auctionNumber: {
             type: Number,
           }
         },
@@ -291,16 +141,14 @@ const showSchema = new Schema(
     },
 
     enabledProductTypes: {
-  buyNow:   { type: Boolean, default: false },
-  auction:  { type: Boolean, default: false },
-  giveaway: { type: Boolean, default: false }
-}
-,
+      buyNow:   { type: Boolean, default: false },
+      auction:  { type: Boolean, default: false },
+      giveaway: { type: Boolean, default: false }
+    },
     notes: {
       type: String,
       default: ''
     },
-    // giveaways: [giveawaySchema], // Array of giveaways
   },
   { timestamps: true }
 );

package/models/stock.model.js

@@ -1,126 +1,85 @@
+
+// models/Stock.js
 import mongoose from "mongoose";
-const { Schema, model } = mongoose;
+const { Schema } = mongoose;
+
+// Sub-schema for manual stock updates
+const StockUpdateHistorySchema = new Schema({
+  change: { type: Number, required: true }, // e.g., +50 or -10
+  previousQuantity: { type: Number, required: true },
+  newQuantity: { type: Number, required: true },
+  reason: { type: String, default: "Manual update by seller" },
+  updatedAt: { type: Date, default: Date.now }
+});
+
 
 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,
-        },
+  {
+    sellerId: {
+      type: Schema.Types.ObjectId,
+      ref: "sellers",
     },
-    { timestamps: true }
+    productListingId: {
+      type: Schema.Types.ObjectId,
+      ref: "productlistings",
+    },
+    title: String,
+    images: [{
+      key: String,
+      url: String
+    }],
+    quantity: {
+      type: Number,
+      min: 0,
+      default: 0,
+    },
+    // History for manual stock adjustments
+    stockUpdateHistory: [StockUpdateHistorySchema],
+    
+    // Track reservations for flash sales
+    flashSaleReservations: [{
+      flashSaleId: {
+        type: Schema.Types.ObjectId,
+        ref: "FlashSale",
+        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 }
+    }],
+    totalReserved: {
+      type: Number,
+      min: 0,
+      default: 0
+    }
+  },
+  { timestamps: true }
 );
 
-const Stock = mongoose.models.stocks || mongoose.model("stocks", StockSchema);
-export default Stock;
+// Pre-save hook to calculate totalReserved
+StockSchema.pre('save', function(next) {
+  if (this.isModified('flashSaleReservations')) {
+    this.totalReserved = this.flashSaleReservations.reduce((total, reservation) => {
+      return total + (['reserved', 'active'].includes(reservation.status) ? reservation.quantity : 0);
+    }, 0);
+  }
+  next();
+});
 
+// Virtual for available quantity
+StockSchema.virtual('availableQuantity').get(function() {
+  return Math.max(0, this.quantity - this.totalReserved);
+});
 
-// 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();
-// });
+// Ensure virtuals are included in JSON output
+StockSchema.set('toJSON', { virtuals: true });
+StockSchema.set('toObject', { virtuals: true });
 
-// // 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 = mongoose.models.stocks || mongoose.model("stocks", StockSchema);
-// export default Stock;
+const Stock = mongoose.models.stocks || mongoose.model("stocks", StockSchema);
+export default Stock;

package/models/user.model.js

@@ -93,7 +93,6 @@ const UserSchema = new mongoose.Schema(
       },
     ],
     filledNewSellerForm: { type: Boolean, default: false },
-
     // --- Verification Flow Fields ---
     verificationFlowStatus: {
       type: String,
@@ -181,7 +180,6 @@ UserSchema.index({
   name: "user_text_index"
 });
 
-
 UserSchema.methods.comparePassword = async function (loginPassword) {
   if (!this.password) return false;
   return bcrypt.compare(loginPassword, this.password);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flykup_model_production",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "main": "index.js",
   "type": "module",
   "private": false,