Razorpay ported to the new payment system

Author: Rajat Saxena

apps/docs/public/assets/schools/payment-setup-razorpay.png

@@ -102,6 +102,7 @@ export const SIDEBAR: Sidebar = {
             { text: "Introduction", link: "en/schools/introduction" },
             { text: "Create a school", link: "en/schools/create" },
             { text: "Use custom domain", link: "en/schools/add-custom-domain" },
+            { text: "Set up payments", link: "en/schools/set-up-payments" },
             { text: "Delete a school", link: "en/schools/delete" },
         ],
         Users: [

apps/docs/public/assets/schools/razorpay-add-webhook.png

@@ -0,0 +1,33 @@
+---
+title: Set up payments
+description: Learn how to get paid via CourseLit
+layout: ../../../layouts/MainLayout.astro
+---
+
+CourseLit offers the following payment methods:
+
+-   [Stripe](https://stripe.com)
+-   [Razorpay](https://razorpay.com)
+
+Your school can only have a single payment method activated at a time.
+
+### Set up Razorpay
+
+1. Sign up for an account on Razorpay and get your business approved.
+2. In the Razorpay dashboard, go to the `Account & Settings` tab and select `API keys` as shown below:  
+   ![Razorpay dashboard](/assets/schools/razorpay-dashboard-api-key.png)
+3. Generate a new API key and keep this screen open.
+4. In your CourseLit school, go to the `Settings > Payment` tab and select `Razorpay` in the `Payment Method` dropdown.
+5. Enter your Razorpay key and its secret in the `Razorpay Key` and `Razorpay Secret Key` input boxes as shown below:  
+   ![Payment setup for Razorpay](/assets/schools/payment-setup-razorpay.png)
+6. Set up the webhooks. Using webhooks, your school receives timely updates about payments from Razorpay.
+7. In the Razorpay dashboard, go to the `Accounts & Settings` tab and select `Webhooks`.
+8. Create a new webhook using the button as shown below:  
+   ![Razorpay new webhook](/assets/schools/razorpay-add-webhook.png)
+9. In the webhook dialog, enter the following:
+    - The webhook URL for your school (listed in the same payment screen in your school).
+    - Check the following events:  
+       - `order.paid`: For confirming one-time payments  
+       - `subscription.charged`: For confirming subscription payments  
+      ![Razorpay webhook configuration](/assets/schools/razorpay-webhook-config.png)
+10. That's it! Your Razorpay configuration is complete, and you are ready to receive payments.

apps/docs/public/assets/schools/razorpay-dashboard-api-key.png

@@ -92,6 +92,10 @@ export default function CheckoutPage() {
                         subscriptionMonthlyAmount
                         subscriptionYearlyAmount
                     }
+                    featuredImage {
+                        thumbnail
+                        file
+                    }
                     autoAcceptMembers
                     joiningReasonText
                 }
@@ -109,6 +113,7 @@ export default function CheckoutPage() {
                     id: response.community.communityId,
                     name: response.community.name,
                     type: MembershipEntityType.COMMUNITY,
+                    featuredImage: response.community.featuredImage.file,
                     joiningReasonText: response.community.joiningReasonText,
                     autoAcceptMembers: response.community.autoAcceptMembers,
                 });

apps/docs/public/assets/schools/razorpay-webhook-config.png

@@ -16,7 +16,7 @@ import constants from "@config/constants";
 import PaymentPlanModel from "@models/PaymentPlan";
 import { getPaymentMethodFromSettings } from "@/payments-new";
 import { generateUniqueId } from "@courselit/utils";
-import Invoice from "@models/Invoice";
+import InvoiceModel from "@models/Invoice";
 import { error } from "@/services/logger";
 import { activateMembership } from "../webhook-new/route";
 import { responses } from "@config/strings";
@@ -148,6 +148,7 @@ export async function POST(req: NextRequest) {
         const metadata = {
             membershipId: membership.membershipId,
             invoiceId,
+            currencyISOCode: siteinfo.currencyISOCode,
         };
 
         const paymentTracker = await paymentMethod.initiate({
@@ -164,7 +165,7 @@ export async function POST(req: NextRequest) {
             origin,
         });
 
-        await Invoice.create({
+        await InvoiceModel.create({
             domain: domain._id,
             invoiceId,
             membershipId: membership.membershipId,
@@ -176,14 +177,18 @@ export async function POST(req: NextRequest) {
                 0,
             status: Constants.InvoiceStatus.PENDING,
             paymentProcessor: paymentMethod.name,
-            paymentProcessorTransactionId: paymentTracker,
+            paymentProcessorEntityId: paymentTracker,
+            currencyISOCode: siteinfo.currencyISOCode,
         });
 
+        membership.subscriptionId = undefined;
+        membership.subscriptionMethod = undefined;
         await (membership as any).save();
 
         return Response.json({
             status: transactionInitiated,
             paymentTracker,
+            metadata,
         });
     } catch (err: any) {
         error(`Error initiating payment: ${err.message}`, {

apps/docs/src/config.ts

@@ -0,0 +1,70 @@
+import { error, info } from "@/services/logger";
+import { NextRequest } from "next/server";
+import DomainModel, { Domain } from "@models/Domain";
+import { validatePaymentVerification } from "razorpay/dist/utils/razorpay-utils";
+import { responses } from "@config/strings";
+import Invoice from "@models/Invoice";
+import { UIConstants } from "@courselit/common-models";
+
+export async function POST(req: NextRequest) {
+    const body = await req.json();
+    const domainName = req.headers.get("domain");
+    const { signature, paymentId, subscriptionId, orderId } = body;
+    if (!signature || !paymentId) {
+        return Response.json({ message: "Bad request" }, { status: 400 });
+    }
+    info(
+        `POST /api/payment/vendor/razorpay/verify: domain detected: ${domainName}`,
+    );
+
+    const domain = await DomainModel.findOne<Domain>({
+        name: domainName,
+    });
+    if (!domain) {
+        return Response.json({ message: "Domain not found" }, { status: 404 });
+    }
+
+    if (!domain.settings.razorpayKey || !domain.settings.razorpaySecret) {
+        return Response.json(
+            { message: "Invalid Razorpay settings" },
+            { status: 500 },
+        );
+    }
+
+    let isVerified = false;
+    if (subscriptionId) {
+        isVerified = validatePaymentVerification(
+            { subscription_id: subscriptionId, payment_id: paymentId },
+            signature,
+            domain.settings.razorpaySecret,
+        );
+    } else {
+        isVerified = validatePaymentVerification(
+            { order_id: orderId, payment_id: paymentId },
+            signature,
+            domain.settings.razorpaySecret,
+        );
+    }
+
+    if (isVerified) {
+        const invoice = await Invoice.findOne({
+            domain: domain._id,
+            paymentProcessor: UIConstants.PAYMENT_METHOD_RAZORPAY,
+            paymentProcessorEntityId: subscriptionId || orderId,
+        });
+        return Response.json({
+            message: responses.success,
+            purchaseId: invoice?.invoiceId,
+        });
+    }
+
+    error(`Could not verify signature`, {
+        domain: domain._id,
+        domainName: domain.name,
+        orderId,
+        paymentId,
+        signature,
+    });
+
+    return Response.json({ error: "Verification failed" }, { status: 400 });
+}

apps/docs/src/pages/en/schools/set-up-payments.md

@@ -43,7 +43,7 @@ export async function POST(req: NextRequest) {
         }
 
         const metadata = paymentMethod.getMetadata(body);
-        const { membershipId, invoiceId } = metadata;
+        const { membershipId, invoiceId, currencyISOCode } = metadata;
 
         const membership = await getMembership(domain._id, membershipId);
         if (!membership) {
@@ -62,11 +62,12 @@ export async function POST(req: NextRequest) {
         );
 
         await handleInvoice(
-            domain._id,
+            domain,
             invoiceId,
             membershipId,
             paymentPlan,
             paymentMethod,
+            currencyISOCode,
             body,
         );
 
@@ -141,21 +142,27 @@ async function handleSubscription(
 }
 
 async function handleInvoice(
-    domainId: mongoose.Types.ObjectId,
+    domain: Domain,
     invoiceId: string,
     membershipId: string,
     paymentPlan: PaymentPlan | null,
     paymentMethod: any,
+    currencyISOCode: string,
     body: any,
 ) {
-    const invoice = await InvoiceModel.findOne<Invoice>({ invoiceId });
+    const invoice = await InvoiceModel.findOne<Invoice>({
+        domain: domain._id,
+        invoiceId,
+        status: Constants.InvoiceStatus.PENDING,
+    });
     if (invoice) {
+        invoice.paymentProcessorTransactionId =
+            paymentMethod.getPaymentIdentifier(body);
         invoice.status = Constants.InvoiceStatus.PAID;
         await (invoice as any).save();
     } else {
         await InvoiceModel.create({
-            domain: domainId,
-            invoiceId,
+            domain: domain._id,
             membershipId,
             amount:
                 paymentPlan?.oneTimeAmount ||
@@ -167,6 +174,7 @@ async function handleInvoice(
             paymentProcessor: paymentMethod.name,
             paymentProcessorTransactionId:
                 paymentMethod.getPaymentIdentifier(body),
+            currencyISOCode,
         });
     }
 }