@feardread/fear 1.1.4 → 1.2.0

package/controllers/payment.js

@@ -1,31 +1,148 @@
 const Razorpay = require("razorpay");
+const paypal = require("@paypal/checkout-server-sdk");
+const Payment = require("../models/payment");
+const methods = require("./crud");
+
 const instance = new Razorpay({
   key_id: "rzp_test_HSSeDI22muUrLR",
   key_secret: "sRO0YkBxvgMg0PvWHJN16Uf7",
 });
 
-const checkout = async (req, res) => {
-  const { amount } = req.body;
-  const option = {
-    amount: amount * 100,
-    currency: "INR",
-  };
-  const order = await instance.orders.create(option);
-  res.json({
-    success: true,
-    order,
-  });
+// Razorpay instance
+const razorpayInstance = new Razorpay({
+  key_id: "rzp_test_HSSeDI22muUrLR",
+  key_secret: "sRO0YkBxvgMg0PvWHJN16Uf7",
+});
+
+// PayPal environment setup
+const paypalEnvironment = () => {
+  const clientId = process.env.PAYPAL_CLIENT_ID || "YOUR_PAYPAL_CLIENT_ID";
+  const clientSecret = process.env.PAYPAL_CLIENT_SECRET || "YOUR_PAYPAL_CLIENT_SECRET";
+  
+  // Use sandbox for testing, live for production
+  return new paypal.core.SandboxEnvironment(clientId, clientSecret);
+  // For production: return new paypal.core.LiveEnvironment(clientId, clientSecret);
+};
+
+const paypalClient = () => {
+  return new paypal.core.PayPalHttpClient(paypalEnvironment());
 };
 
-const paymentVerification = async (req, res) => {
-  const { razorpayOrderId, razorpayPaymentId } = req.body;
-  res.json({
-    razorpayOrderId,
-    razorpayPaymentId,
-  });
+exports.checkout = async (req, res) => {
+  try {
+    const { amount } = req.body;
+    const option = {
+      amount: amount * 100,
+      currency: "INR",
+    };
+    const order = await razorpayInstance.orders.create(option);
+    res.json({
+      success: true,
+      order,
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: "Error creating Razorpay order",
+      error: error.message,
+    });
+  }
 };
 
-module.exports = {
-  checkout,
-  paymentVerification,
+exports.paymentVerification = async (req, res) => {
+  try {
+    const { razorpayOrderId, razorpayPaymentId, razorpaySignature } = req.body;
+    
+    // Verify signature for security
+    const crypto = require("crypto");
+    const generatedSignature = crypto
+      .createHmac("sha256", "sRO0YkBxvgMg0PvWHJN16Uf7")
+      .update(`${razorpayOrderId}|${razorpayPaymentId}`)
+      .digest("hex");
+    
+    if (generatedSignature === razorpaySignature) {
+      res.json({
+        success: true,
+        razorpayOrderId,
+        razorpayPaymentId,
+        verified: true,
+      });
+    } else {
+      res.status(400).json({
+        success: false,
+        message: "Payment verification failed",
+      });
+    }
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: "Error verifying payment",
+      error: error.message,
+    });
+  }
 };
+
+// ============ PAYPAL METHODS ============
+
+const createPayPalOrder = async (req, res) => {
+  try {
+    const { amount, currency = "USD" } = req.body;
+    
+    const request = new paypal.orders.OrdersCreateRequest();
+    request.prefer("return=representation");
+    request.requestBody({
+      intent: "CAPTURE",
+      purchase_units: [{
+        amount: {
+          currency_code: currency,
+          value: amount.toString(),
+        },
+      }],
+    });
+    
+    const order = await paypalClient().execute(request);
+    
+    res.json({
+      success: true,
+      orderId: order.result.id,
+      order: order.result,
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: "Error creating PayPal order",
+      error: error.message,
+    });
+  }
+};
+
+const capturePayPalOrder = async (req, res) => {
+  try {
+    const { orderId } = req.body;
+    
+    const request = new paypal.orders.OrdersCaptureRequest(orderId);
+    request.requestBody({});
+    
+    const capture = await paypalClient().execute(request);
+    
+    res.json({
+      success: true,
+      captureId: capture.result.id,
+      status: capture.result.status,
+      capture: capture.result,
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: "Error capturing PayPal order",
+      error: error.message,
+    });
+  }
+};
+
+const crud = methods.crudController( Payment );
+for(prop in crud) {
+  if(crud.hasOwnProperty(prop)) {
+    module.exports[prop] = crud[prop];
+  }
+}

package/models/order.js

@@ -1,26 +1,152 @@
-const mongoose = require("mongoose"); // Erase if already required
+const mongoose = require("mongoose");
 
-// Declare the Schema of the Mongo model
-var orderSchema = new mongoose.Schema(
+const orderItemSchema = new mongoose.Schema({
+  productId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Product",
+    required: true,
+  },
+  name: {
+    type: String,
+    required: true,
+  },
+  quantity: {
+    type: Number,
+    required: true,
+    min: 1,
+  },
+  price: {
+    type: Number,
+    required: true,
+  },
+  discount: {
+    type: Number,
+    default: 0,
+  },
+  tax: {
+    type: Number,
+    default: 0,
+  },
+  subtotal: {
+    type: Number,
+    required: true,
+  },
+  image: String,
+  sku: String,
+  attributes: {
+    type: Map,
+    of: String, // For size, color, etc.
+  },
+});
+
+const orderSchema = new mongoose.Schema(
   {
-    user: {
+    orderNumber: {
+      type: String,
+      unique: true,
+      required: true,
+    },
+    userId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",
       required: true,
+      index: true,
+    },
+    // Order Items
+    items: [orderItemSchema],
+    
+    // Pricing
+    subtotal: {
+      type: Number,
+      required: true,
+    },
+    discount: {
+      type: Number,
+      default: 0,
+    },
+    tax: {
+      type: Number,
+      default: 0,
+    },
+    shippingCost: {
+      type: Number,
+      default: 0,
+    },
+    total: {
+      type: Number,
+      required: true,
+    },
+    currency: {
+      type: String,
+      default: "INR",
+      enum: ["INR", "USD", "EUR", "GBP"],
+    },
+    
+    // Payment Information
+    paymentMethod: {
+      type: String,
+      enum: ["razorpay", "paypal", "card", "upi", "netbanking", "cod"],
+      required: true,
     },
-    shippingInfo: {
-      firstname: {
+    paymentStatus: {
+      type: String,
+      enum: ["pending", "processing", "completed", "failed", "refunded", "partially_refunded"],
+      default: "pending",
+      index: true,
+    },
+    paymentDetails: {
+      // Razorpay
+      razorpayOrderId: String,
+      razorpayPaymentId: String,
+      razorpaySignature: String,
+      
+      // PayPal
+      paypalOrderId: String,
+      paypalCaptureId: String,
+      
+      // Common
+      transactionId: String,
+      paymentMethodId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "PaymentMethod",
+      },
+      paidAt: Date,
+    },
+    
+    // Order Status
+    orderStatus: {
+      type: String,
+      enum: [
+        "pending",
+        "confirmed",
+        "processing",
+        "shipped",
+        "out_for_delivery",
+        "delivered",
+        "cancelled",
+        "returned",
+        "refunded"
+      ],
+      default: "pending",
+      index: true,
+    },
+    
+    // Shipping Information
+    shippingAddress: {
+      name: {
         type: String,
         required: true,
       },
-      lastname: {
+      phone: {
         type: String,
         required: true,
       },
-      address: {
+      email: String,
+      line1: {
         type: String,
         required: true,
       },
+      line2: String,
       city: {
         type: String,
         required: true,
@@ -29,60 +155,88 @@ var orderSchema = new mongoose.Schema(
         type: String,
         required: true,
       },
-      other: {
+      postalCode: {
         type: String,
-      },
-      pincode: {
-        type: Number,
         required: true,
       },
-    },
-    paymentInfo: {
-      razorpayOrderId: {
-        type: String,
-        required: true,
-      },
-      razorpayPaymentId: {
+      country: {
         type: String,
         required: true,
+        default: "IN",
       },
+      landmark: String,
     },
-    orderItems: [
+    
+    billingAddress: {
+      name: String,
+      phone: String,
+      email: String,
+      line1: String,
+      line2: String,
+      city: String,
+      state: String,
+      postalCode: String,
+      country: String,
+    },
+    
+    // Shipping Details
+    shippingProvider: String,
+    trackingNumber: String,
+    estimatedDeliveryDate: Date,
+    actualDeliveryDate: Date,
+    
+    // Status History
+    statusHistory: [
       {
-        product: {
-          type: mongoose.Schema.Types.ObjectId,
-          ref: "Product",
-          required: true,
+        status: String,
+        timestamp: {
+          type: Date,
+          default: Date.now,
         },
-        quantity: {
-          type: Number,
-          required: true,
-        },
-        price: {
-          type: Number,
-          required: true,
+        note: String,
+        updatedBy: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "User",
         },
       },
     ],
-    paidAt: {
-      type: Date,
-      default: Date.now(),
-    },
-    month: {
+    
+    // Discount/Coupon
+    couponCode: String,
+    couponDiscount: {
       type: Number,
-      default: new Date().getMonth(),
+      default: 0,
     },
-    totalPrice: {
-      type: Number,
-      required: true,
-    },
-    totalPriceAfterDiscount: {
-      type: Number,
-      required: true,
+    
+    // Notes
+    customerNote: String,
+    internalNote: String,
+    
+    // Cancellation/Return
+    cancellationReason: String,
+    cancelledAt: Date,
+    cancelledBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
     },
-    orderStatus: {
+    
+    returnReason: String,
+    returnedAt: Date,
+    
+    // Refund Information
+    refundAmount: Number,
+    refundStatus: {
       type: String,
-      default: "Ordered",
+      enum: ["none", "pending", "processing", "completed", "failed"],
+      default: "none",
+    },
+    refundedAt: Date,
+    refundTransactionId: String,
+    
+    // Metadata
+    metadata: {
+      type: Map,
+      of: mongoose.Schema.Types.Mixed,
     },
   },
   {
@@ -90,5 +244,150 @@ var orderSchema = new mongoose.Schema(
   }
 );
 
-//Export the model
-module.exports = mongoose.model("Order", orderSchema);
+// Indexes for better query performance
+orderSchema.index({ orderNumber: 1 });
+orderSchema.index({ userId: 1, createdAt: -1 });
+orderSchema.index({ orderStatus: 1, createdAt: -1 });
+orderSchema.index({ paymentStatus: 1 });
+orderSchema.index({ "paymentDetails.razorpayOrderId": 1 });
+orderSchema.index({ "paymentDetails.paypalOrderId": 1 });
+orderSchema.index({ trackingNumber: 1 });
+
+// Pre-save middleware to generate order number
+orderSchema.pre("save", async function (next) {
+  if (!this.orderNumber) {
+    const timestamp = Date.now().toString(36).toUpperCase();
+    const random = Math.random().toString(36).substring(2, 7).toUpperCase();
+    this.orderNumber = `ORD-${timestamp}-${random}`;
+  }
+  next();
+});
+
+// Pre-save middleware to add status history
+orderSchema.pre("save", function (next) {
+  if (this.isModified("orderStatus")) {
+    this.statusHistory.push({
+      status: this.orderStatus,
+      timestamp: new Date(),
+    });
+  }
+  next();
+});
+
+// Static method to get orders by user
+orderSchema.statics.getUserOrders = async function (userId, options = {}) {
+  const { status, limit = 10, skip = 0 } = options;
+  const query = { userId };
+  
+  if (status) {
+    query.orderStatus = status;
+  }
+  
+  return await this.find(query)
+    .sort({ createdAt: -1 })
+    .limit(limit)
+    .skip(skip)
+    .populate("items.productId", "name images")
+    .populate("paymentDetails.paymentMethodId");
+};
+
+// Static method to get order statistics
+orderSchema.statics.getOrderStats = async function (userId) {
+  const stats = await this.aggregate([
+    { $match: { userId: mongoose.Types.ObjectId(userId) } },
+    {
+      $group: {
+        _id: "$orderStatus",
+        count: { $sum: 1 },
+        totalAmount: { $sum: "$total" },
+      },
+    },
+  ]);
+  
+  return stats;
+};
+
+// Instance method to mark as paid
+orderSchema.methods.markAsPaid = async function (paymentInfo) {
+  this.paymentStatus = "completed";
+  this.paymentDetails = {
+    ...this.paymentDetails,
+    ...paymentInfo,
+    paidAt: new Date(),
+  };
+  this.orderStatus = "confirmed";
+  return await this.save();
+};
+
+// Instance method to update order status
+orderSchema.methods.updateStatus = async function (status, note, updatedBy) {
+  this.orderStatus = status;
+  this.statusHistory.push({
+    status,
+    timestamp: new Date(),
+    note,
+    updatedBy,
+  });
+  
+  // Update specific dates based on status
+  if (status === "delivered") {
+    this.actualDeliveryDate = new Date();
+  } else if (status === "cancelled") {
+    this.cancelledAt = new Date();
+    this.cancelledBy = updatedBy;
+  } else if (status === "returned") {
+    this.returnedAt = new Date();
+  }
+  
+  return await this.save();
+};
+
+// Instance method to process refund
+orderSchema.methods.processRefund = async function (amount, transactionId) {
+  this.refundAmount = amount || this.total;
+  this.refundStatus = "completed";
+  this.refundedAt = new Date();
+  this.refundTransactionId = transactionId;
+  this.paymentStatus = amount >= this.total ? "refunded" : "partially_refunded";
+  this.orderStatus = "refunded";
+  return await this.save();
+};
+
+// Instance method to add tracking information
+orderSchema.methods.addTracking = async function (provider, trackingNumber, estimatedDelivery) {
+  this.shippingProvider = provider;
+  this.trackingNumber = trackingNumber;
+  this.estimatedDeliveryDate = estimatedDelivery;
+  this.orderStatus = "shipped";
+  return await this.save();
+};
+
+// Virtual for order age in days
+orderSchema.virtual("orderAge").get(function () {
+  return Math.floor((Date.now() - this.createdAt) / (1000 * 60 * 60 * 24));
+});
+
+// Virtual for items count
+orderSchema.virtual("itemsCount").get(function () {
+  return this.items.reduce((total, item) => total + item.quantity, 0);
+});
+
+// Virtual for checking if order can be cancelled
+orderSchema.virtual("canCancel").get(function () {
+  return ["pending", "confirmed", "processing"].includes(this.orderStatus);
+});
+
+// Virtual for checking if order can be returned
+orderSchema.virtual("canReturn").get(function () {
+  const returnWindow = 7; // days
+  return (
+    this.orderStatus === "delivered" &&
+    this.orderAge <= returnWindow
+  );
+});
+
+// Ensure virtuals are included in JSON
+orderSchema.set("toJSON", { virtuals: true });
+orderSchema.set("toObject", { virtuals: true });
+
+module.exports = mongoose.model("Order", orderSchema);

package/models/payment.js

@@ -0,0 +1,198 @@
+const mongoose = require("mongoose");
+const crypto = require("crypto");
+
+const paymentMethodSchema = new mongoose.Schema(
+  {
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true,
+      index: true,
+    },
+    paymentType: {
+      type: String,
+      enum: ["razorpay", "paypal", "card", "upi", "netbanking"],
+      required: true,
+    },
+    paymentToken: {
+      type: String,
+      required: true,
+      // This stores the tokenized payment method from the payment gateway
+    },
+    isDefault: {
+      type: Boolean,
+      default: false,
+    },
+    isActive: {
+      type: Boolean,
+      default: true,
+    },
+    // Card/Payment details (only non-sensitive info for display)
+    cardDetails: {
+      last4: {
+        type: String,
+        maxlength: 4,
+      },
+      brand: {
+        type: String, // Visa, Mastercard, Amex, etc.
+      },
+      expiryMonth: {
+        type: String,
+        maxlength: 2,
+      },
+      expiryYear: {
+        type: String,
+        maxlength: 4,
+      },
+      cardholderName: {
+        type: String,
+      },
+      fingerprint: {
+        type: String, // Unique identifier for the card
+      },
+    },
+    // PayPal details
+    paypalDetails: {
+      email: {
+        type: String,
+      },
+      payerId: {
+        type: String,
+      },
+    },
+    // UPI details
+    upiDetails: {
+      vpa: {
+        type: String, // Virtual Payment Address (e.g., user@paytm)
+      },
+    },
+    // Billing address
+    billingAddress: {
+      name: String,
+      line1: String,
+      line2: String,
+      city: String,
+      state: String,
+      postalCode: String,
+      country: {
+        type: String,
+        default: "IN",
+      },
+    },
+    // Metadata for additional information
+    metadata: {
+      type: Map,
+      of: String,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Indexes for better query performance
+paymentMethodSchema.index({ userId: 1, isDefault: 1 });
+paymentMethodSchema.index({ userId: 1, isActive: 1 });
+paymentMethodSchema.index({ createdAt: -1 });
+
+// Middleware to ensure only one default payment method per user
+paymentMethodSchema.pre("save", async function (next) {
+  if (this.isDefault && this.isModified("isDefault")) {
+    // Remove default flag from other payment methods for this user
+    await mongoose.model("PaymentMethod").updateMany(
+      {
+        userId: this.userId,
+        _id: { $ne: this._id },
+        isDefault: true,
+      },
+      { isDefault: false }
+    );
+  }
+  next();
+});
+paymentMethodSchema.statics.getDefaultPaymentMethod = async function (userId) {
+  return await this.findOne({
+    userId,
+    isDefault: true,
+    isActive: true,
+  });
+};
+paymentMethodSchema.statics.getUserPaymentMethods = async function (userId) {
+  return await this.find({
+    userId,
+    isActive: true,
+  }).sort({ isDefault: -1, createdAt: -1 });
+};
+
+paymentMethodSchema.methods.setAsDefault = async function () {
+  await mongoose.model("PaymentMethod").updateMany(
+    {
+      userId: this.userId,
+      _id: { $ne: this._id },
+    },
+    { isDefault: false }
+  );
+  
+  this.isDefault = true;
+  return await this.save();
+};
+paymentMethodSchema.methods.softDelete = async function () {
+  this.isActive = false;
+  if (this.isDefault) {
+    this.isDefault = false;
+    // Optionally set another method as default
+    const otherMethod = await mongoose.model("PaymentMethod").findOne({
+      userId: this.userId,
+      _id: { $ne: this._id },
+      isActive: true,
+    });
+    if (otherMethod) {
+      otherMethod.isDefault = true;
+      await otherMethod.save();
+    }
+  }
+  return await this.save();
+};
+
+// Virtual for masked card number display
+paymentMethodSchema.virtual("displayNumber").get(function () {
+  if (this.cardDetails?.last4) {
+    return `•••• •••• •••• ${this.cardDetails.last4}`;
+  }
+  if (this.paypalDetails?.email) {
+    return this.paypalDetails.email;
+  }
+  if (this.upiDetails?.vpa) {
+    return this.upiDetails.vpa;
+  }
+  return "Payment Method";
+});
+
+// Virtual for expiry display
+paymentMethodSchema.virtual("expiryDisplay").get(function () {
+  if (this.cardDetails?.expiryMonth && this.cardDetails?.expiryYear) {
+    return `${this.cardDetails.expiryMonth}/${this.cardDetails.expiryYear}`;
+  }
+  return null;
+});
+
+// Virtual for checking if card is expired
+paymentMethodSchema.virtual("isExpired").get(function () {
+  if (this.cardDetails?.expiryMonth && this.cardDetails?.expiryYear) {
+    const now = new Date();
+    const expiryDate = new Date(
+      parseInt(this.cardDetails.expiryYear),
+      parseInt(this.cardDetails.expiryMonth) - 1
+    );
+    return now > expiryDate;
+  }
+  return false;
+});
+
+// Ensure virtuals are included in JSON
+paymentMethodSchema.set("toJSON", { virtuals: true });
+paymentMethodSchema.set("toObject", { virtuals: true });
+
+const PaymentMethod = mongoose.model("PaymentMethod", paymentMethodSchema);
+
+module.exports = PaymentMethod;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feardread/fear",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "",
   "main": "index.js",
   "scripts": {

package/routes/payment.js

@@ -0,0 +1,17 @@
+const Payment = require('../controllers/payment');
+
+module.exports = (fear) => {
+    const router = fear.createRouter();
+    const handler = fear.getHandler();
+    const validator = fear.getValidator();
+
+    router.get("/all", Payment.list);
+    router.post("/new", Payment.create);
+    
+    router.route('/:id')
+        .get(Payment.read)
+        .put(Payment.update);
+
+
+    return router;
+}