unified-video-framework 1.4.21 → 1.4.22

package/packages/web/src/paywall/PaymentGatewayAdapter.ts

@@ -0,0 +1,346 @@
+/**
+ * Payment Gateway Adapter Interface for Unified Video Framework
+ * Provides a standardized way to integrate custom payment gateways
+ */
+
+export interface PaymentRequest {
+  userId: string;
+  videoId: string | number;
+  amount: number;
+  currency: string;
+  successUrl?: string;
+  cancelUrl?: string;
+  metadata?: Record<string, any>;
+  customData?: Record<string, any>;
+}
+
+export interface PaymentResponse {
+  success: boolean;
+  paymentUrl?: string;
+  paymentData?: any;
+  orderId?: string;
+  sessionId?: string;
+  error?: string;
+  message?: string;
+}
+
+export interface VerificationRequest {
+  orderId?: string;
+  sessionId?: string;
+  userId: string;
+  videoId: string | number;
+  customData?: Record<string, any>;
+}
+
+export interface VerificationResponse {
+  success: boolean;
+  verified: boolean;
+  accessGranted: boolean;
+  error?: string;
+  message?: string;
+  data?: any;
+}
+
+export interface PaymentGatewayConfig {
+  name: string;
+  displayName: string;
+  apiBase: string;
+  endpoints: {
+    createPayment: string;
+    verifyPayment?: string;
+  };
+  headers?: Record<string, string>;
+  customHandler?: (request: PaymentRequest, config: PaymentGatewayConfig) => Promise<PaymentResponse>;
+  verifyHandler?: (request: VerificationRequest, config: PaymentGatewayConfig) => Promise<VerificationResponse>;
+}
+
+export abstract class PaymentGatewayAdapter {
+  protected config: PaymentGatewayConfig;
+
+  constructor(config: PaymentGatewayConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Create payment session/order
+   */
+  abstract createPayment(request: PaymentRequest): Promise<PaymentResponse>;
+
+  /**
+   * Verify payment completion
+   */
+  abstract verifyPayment(request: VerificationRequest): Promise<VerificationResponse>;
+
+  /**
+   * Get gateway display name
+   */
+  getDisplayName(): string {
+    return this.config.displayName || this.config.name;
+  }
+
+  /**
+   * Get gateway identifier
+   */
+  getName(): string {
+    return this.config.name;
+  }
+}
+
+/**
+ * Generic Payment Gateway Adapter using fetch API
+ */
+export class GenericPaymentGateway extends PaymentGatewayAdapter {
+  async createPayment(request: PaymentRequest): Promise<PaymentResponse> {
+    try {
+      // Use custom handler if provided
+      if (this.config.customHandler) {
+        return await this.config.customHandler(request, this.config);
+      }
+
+      // Default fetch implementation
+      const response = await fetch(`${this.config.apiBase}${this.config.endpoints.createPayment}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.config.headers
+        },
+        body: JSON.stringify(request)
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.message || `HTTP ${response.status}`,
+          message: data.message || 'Payment creation failed'
+        };
+      }
+
+      return {
+        success: true,
+        paymentUrl: data.paymentUrl || data.Payment_Link_URL,
+        paymentData: data,
+        orderId: data.orderId || data.order_id,
+        sessionId: data.sessionId || data.session_id
+      };
+
+    } catch (error) {
+      console.error(`[${this.config.name}] Payment creation error:`, error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+        message: 'Network error occurred'
+      };
+    }
+  }
+
+  async verifyPayment(request: VerificationRequest): Promise<VerificationResponse> {
+    try {
+      // Use custom verify handler if provided
+      if (this.config.verifyHandler) {
+        return await this.config.verifyHandler(request, this.config);
+      }
+
+      // Skip verification if no endpoint provided
+      if (!this.config.endpoints.verifyPayment) {
+        return {
+          success: true,
+          verified: true,
+          accessGranted: true,
+          message: 'Verification skipped - assuming success'
+        };
+      }
+
+      const response = await fetch(`${this.config.apiBase}${this.config.endpoints.verifyPayment}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.config.headers
+        },
+        body: JSON.stringify(request)
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        return {
+          success: false,
+          verified: false,
+          accessGranted: false,
+          error: data.message || `HTTP ${response.status}`,
+          message: data.message || 'Payment verification failed'
+        };
+      }
+
+      return {
+        success: true,
+        verified: data.verified !== false,
+        accessGranted: data.accessGranted !== false,
+        data: data
+      };
+
+    } catch (error) {
+      console.error(`[${this.config.name}] Payment verification error:`, error);
+      return {
+        success: false,
+        verified: false,
+        accessGranted: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+        message: 'Network error during verification'
+      };
+    }
+  }
+}
+
+/**
+ * Cashfree Payment Gateway Adapter
+ * Customized for your specific Cashfree API
+ */
+export class CashfreePaymentGateway extends PaymentGatewayAdapter {
+  async createPayment(request: PaymentRequest): Promise<PaymentResponse> {
+    try {
+      console.log('[Cashfree] Creating payment with request:', request);
+
+      // Get session token for authentication
+      const sessionToken = sessionStorage.getItem('uvf_session_token');
+      
+      if (!sessionToken) {
+        throw new Error('User session token not found');
+      }
+
+      const cashfreeRequest = {
+        unit_amount: request.amount,
+        source_type_id: 1, // Video content type
+        source_id: request.videoId, // This will be the video slug
+        success_url: request.successUrl || `${window.location.origin}${window.location.pathname}?payment=success`,
+        failure_url: request.cancelUrl || `${window.location.origin}${window.location.pathname}?payment=failed`,
+        Login_device_type: 'Web',
+        ...request.customData
+      };
+
+      console.log('[Cashfree] Sending request to:', `${this.config.apiBase}${this.config.endpoints.createPayment}`);
+      console.log('[Cashfree] Request payload:', cashfreeRequest);
+
+      const response = await fetch(`${this.config.apiBase}${this.config.endpoints.createPayment}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${sessionToken}`,
+          ...this.config.headers
+        },
+        body: JSON.stringify(cashfreeRequest)
+      });
+
+      const data = await response.json();
+      console.log('[Cashfree] API Response:', data);
+
+      if (!response.ok || !data.status) {
+        return {
+          success: false,
+          error: data.message || `HTTP ${response.status}`,
+          message: data.message || 'Cashfree payment creation failed'
+        };
+      }
+
+      return {
+        success: true,
+        paymentUrl: data.Payment_Link_URL,
+        paymentData: data,
+        orderId: data.order_id || data.orderId
+      };
+
+    } catch (error) {
+      console.error('[Cashfree] Payment creation error:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+        message: 'Network error occurred'
+      };
+    }
+  }
+
+  async verifyPayment(request: VerificationRequest): Promise<VerificationResponse> {
+    // For Cashfree, verification might be handled by webhooks or return URL
+    // Since your implementation uses return URLs, we'll assume success if we reach this point
+    console.log('[Cashfree] Payment verification requested:', request);
+    
+    return {
+      success: true,
+      verified: true,
+      accessGranted: true,
+      message: 'Cashfree payment completed via return URL'
+    };
+  }
+}
+
+/**
+ * Payment Gateway Manager
+ * Manages multiple payment gateway adapters
+ */
+export class PaymentGatewayManager {
+  private gateways: Map<string, PaymentGatewayAdapter> = new Map();
+
+  /**
+   * Register a payment gateway adapter
+   */
+  registerGateway(gateway: PaymentGatewayAdapter): void {
+    this.gateways.set(gateway.getName(), gateway);
+    console.log(`[PaymentGatewayManager] Registered gateway: ${gateway.getName()}`);
+  }
+
+  /**
+   * Get a registered gateway by name
+   */
+  getGateway(name: string): PaymentGatewayAdapter | undefined {
+    return this.gateways.get(name);
+  }
+
+  /**
+   * Get all registered gateway names
+   */
+  getGatewayNames(): string[] {
+    return Array.from(this.gateways.keys());
+  }
+
+  /**
+   * Check if a gateway is registered
+   */
+  hasGateway(name: string): boolean {
+    return this.gateways.has(name);
+  }
+
+  /**
+   * Create payment using specified gateway
+   */
+  async createPayment(gatewayName: string, request: PaymentRequest): Promise<PaymentResponse> {
+    const gateway = this.getGateway(gatewayName);
+    if (!gateway) {
+      return {
+        success: false,
+        error: `Gateway '${gatewayName}' not found`,
+        message: `Payment gateway '${gatewayName}' is not registered`
+      };
+    }
+
+    return await gateway.createPayment(request);
+  }
+
+  /**
+   * Verify payment using specified gateway
+   */
+  async verifyPayment(gatewayName: string, request: VerificationRequest): Promise<VerificationResponse> {
+    const gateway = this.getGateway(gatewayName);
+    if (!gateway) {
+      return {
+        success: false,
+        verified: false,
+        accessGranted: false,
+        error: `Gateway '${gatewayName}' not found`,
+        message: `Payment gateway '${gatewayName}' is not registered`
+      };
+    }
+
+    return await gateway.verifyPayment(request);
+  }
+}