Merge pull request #322 from dreamgene/feature/299-monetization-integration

Feature/299 monetization integration

Author: aji70

backend/src/app.module.ts

@@ -34,6 +34,7 @@ import { CouponsModule } from './modules/coupons/coupons.module';
 import { PerksModule } from './modules/perks/perks.module';
 import { PerksBoostsModule } from './modules/perks-boosts/perks-boosts.module';
 import { AdminAnalyticsModule } from './modules/admin-analytics/admin-analytics.module';
+import { MonetizationModule } from './modules/monetization/monetization.module';
 
 @Module({
   imports: [
@@ -95,6 +96,7 @@ import { AdminAnalyticsModule } from './modules/admin-analytics/admin-analytics.
     PerksModule,
     PerksBoostsModule,
     AdminAnalyticsModule,
+    MonetizationModule,
   ],
   controllers: [AppController, HealthController],
   providers: [

backend/src/main.ts

@@ -8,7 +8,7 @@ import { AllExceptionsFilter } from './common/filters/all-exceptions.filter';
 import { LoggerService } from './common/logger/logger.service';
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
+  const app = await NestFactory.create(AppModule, { rawBody: true });
 
   // Use Winston logger
   const winstonLogger = app.get(WINSTON_MODULE_NEST_PROVIDER);

backend/src/modules/monetization/coupons/couponService.spec.ts

@@ -0,0 +1,53 @@
+import { CouponService } from './couponService';
+
+describe('CouponService', () => {
+  const couponsService = {
+    validateCoupon: jest.fn(),
+    applyCoupon: jest.fn(),
+  };
+
+  let service: CouponService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new CouponService(couponsService as any);
+  });
+
+  it('returns invalid response for invalid coupons', async () => {
+    couponsService.validateCoupon.mockResolvedValue({ valid: false, message: 'Invalid coupon code' });
+
+    const result = await service.validateAndApplyCoupon({
+      code: 'BADCODE',
+      shopItemId: 10,
+      purchaseAmount: 100,
+    });
+
+    expect(result).toEqual({
+      valid: false,
+      reason: 'Invalid coupon code',
+      originalAmount: 100,
+      discountAmount: 0,
+      finalAmount: 100,
+    });
+    expect(couponsService.applyCoupon).not.toHaveBeenCalled();
+  });
+
+  it('applies discount for valid coupons', async () => {
+    couponsService.validateCoupon.mockResolvedValue({ valid: true, message: 'Coupon is valid' });
+    couponsService.applyCoupon.mockResolvedValue(25);
+
+    const result = await service.validateAndApplyCoupon({
+      code: 'SAVE25',
+      shopItemId: 10,
+      purchaseAmount: 100,
+    });
+
+    expect(result).toEqual({
+      valid: true,
+      reason: 'Coupon is valid',
+      originalAmount: 100,
+      discountAmount: 25,
+      finalAmount: 75,
+    });
+  });
+});

backend/src/modules/monetization/coupons/couponService.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { CouponsService } from '../../coupons/coupons.service';
+
+@Injectable()
+export class CouponService {
+  constructor(private readonly couponsService: CouponsService) {}
+
+  async validateAndApplyCoupon(params: {
+    code: string;
+    shopItemId: number;
+    purchaseAmount: number;
+  }) {
+    const validation = await this.couponsService.validateCoupon({
+      code: params.code,
+      shop_item_id: params.shopItemId,
+      purchase_amount: params.purchaseAmount,
+    });
+
+    if (!validation.valid) {
+      return {
+        valid: false,
+        reason: validation.message,
+        originalAmount: params.purchaseAmount,
+        discountAmount: 0,
+        finalAmount: params.purchaseAmount,
+      };
+    }
+
+    const discountAmount = await this.couponsService.applyCoupon(
+      params.code,
+      params.shopItemId,
+      params.purchaseAmount,
+    );
+
+    return {
+      valid: true,
+      reason: validation.message,
+      originalAmount: params.purchaseAmount,
+      discountAmount,
+      finalAmount: Math.max(0, params.purchaseAmount - discountAmount),
+    };
+  }
+}

backend/src/modules/monetization/monetization.controller.ts

@@ -0,0 +1,57 @@
+import { Body, Controller, Headers, Post, Req, BadRequestException } from '@nestjs/common';
+import { Request } from 'express';
+import { PaymentWebhook } from './webhooks/paymentWebhook';
+import type { PaymentWebhookEvent } from './webhooks/paymentWebhook';
+import { CouponService } from './coupons/couponService';
+import { EventRewards, MonetizationEvent } from './rewards/eventRewards';
+
+@Controller('monetization')
+export class MonetizationController {
+  constructor(
+    private readonly paymentWebhook: PaymentWebhook,
+    private readonly couponService: CouponService,
+    private readonly eventRewards: EventRewards,
+  ) {}
+
+  @Post('webhooks/payment')
+  async handlePaymentWebhook(
+    @Req() req: Request & { rawBody?: Buffer },
+    @Headers('stripe-signature') stripeSignature: string | undefined,
+    @Body() event: PaymentWebhookEvent,
+  ) {
+    const forwardedProto = req.headers['x-forwarded-proto'];
+    if (forwardedProto && String(forwardedProto).toLowerCase() !== 'https') {
+      throw new BadRequestException('Webhook endpoint requires HTTPS');
+    }
+
+    const payload = req.rawBody
+      ? req.rawBody.toString('utf8')
+      : JSON.stringify(event);
+
+    return this.paymentWebhook.handlePaymentWebhook(payload, stripeSignature, event);
+  }
+
+  @Post('coupons/validate')
+  async validateCoupon(
+    @Body() body: { code: string; shopItemId: number; purchaseAmount: number },
+  ) {
+    return this.couponService.validateAndApplyCoupon(body);
+  }
+
+  @Post('rewards/events')
+  async processRewardEvent(
+    @Body()
+    body: {
+      event: MonetizationEvent;
+      payload: {
+        userId: number;
+        level?: number;
+        perkId?: number;
+        quantity?: number;
+        grantedBy?: string;
+      };
+    },
+  ) {
+    return this.eventRewards.processEvent(body.event, body.payload);
+  }
+}

backend/src/modules/monetization/monetization.module.ts

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { MonetizationController } from './monetization.controller';
+import { PaymentWebhook } from './webhooks/paymentWebhook';
+import { RewardEngine } from './rewards/rewardEngine';
+import { CouponService } from './coupons/couponService';
+import { EventRewards } from './rewards/eventRewards';
+import { Purchase } from '../shop/entities/purchase.entity';
+import { ShopModule } from '../shop/shop.module';
+import { CouponsModule } from '../coupons/coupons.module';
+import { PerksModule } from '../perks/perks.module';
+import { PerksBoostsModule } from '../perks-boosts/perks-boosts.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Purchase]),
+    ShopModule,
+    CouponsModule,
+    PerksModule,
+    PerksBoostsModule,
+  ],
+  controllers: [MonetizationController],
+  providers: [PaymentWebhook, RewardEngine, CouponService, EventRewards],
+  exports: [PaymentWebhook, RewardEngine, CouponService, EventRewards],
+})
+export class MonetizationModule {}

backend/src/modules/monetization/rewards/eventRewards.spec.ts

@@ -0,0 +1,40 @@
+import { BadRequestException } from '@nestjs/common';
+import { EventRewards } from './eventRewards';
+
+describe('EventRewards', () => {
+  const rewardEngine = {
+    earnPerk: jest.fn(),
+    grantPromotionalPerk: jest.fn(),
+  };
+
+  let service: EventRewards;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    rewardEngine.earnPerk.mockResolvedValue({ granted: true });
+    rewardEngine.grantPromotionalPerk.mockResolvedValue({ granted: true, promotional: true });
+    service = new EventRewards(rewardEngine as any);
+  });
+
+  it('grants rewards on level.up when level threshold is met', async () => {
+    await service.processEvent('level.up', { userId: 1, level: 10, perkId: 7, quantity: 1 });
+
+    expect(rewardEngine.earnPerk).toHaveBeenCalledWith({
+      userId: 1,
+      perkId: 7,
+      quantity: 1,
+      source: 'event:level.up',
+    });
+  });
+
+  it('returns no reward below level threshold', async () => {
+    const result = await service.processEvent('level.up', { userId: 1, level: 9, perkId: 7 });
+    expect(result).toEqual({ granted: false, reason: 'No reward rule matched' });
+  });
+
+  it('requires grantedBy for promotional grants', async () => {
+    await expect(
+      service.processEvent('admin.promotional.grant', { userId: 1, perkId: 7 }),
+    ).rejects.toThrow(BadRequestException);
+  });
+});

backend/src/modules/monetization/rewards/eventRewards.ts

@@ -0,0 +1,62 @@
+import { Injectable, BadRequestException } from '@nestjs/common';
+import { RewardEngine } from './rewardEngine';
+
+export type MonetizationEvent =
+  | 'level.up'
+  | 'first.purchase'
+  | 'daily.login'
+  | 'admin.promotional.grant';
+
+interface EventRewardPayload {
+  userId: number;
+  level?: number;
+  perkId?: number;
+  quantity?: number;
+  grantedBy?: string;
+}
+
+@Injectable()
+export class EventRewards {
+  constructor(private readonly rewardEngine: RewardEngine) {}
+
+  async processEvent(event: MonetizationEvent, payload: EventRewardPayload) {
+    switch (event) {
+      case 'level.up':
+        if ((payload.level || 0) < 10 || !payload.perkId) {
+          return { granted: false, reason: 'No reward rule matched' };
+        }
+        return this.rewardEngine.earnPerk({
+          userId: payload.userId,
+          perkId: payload.perkId,
+          quantity: payload.quantity || 1,
+          source: 'event:level.up',
+        });
+
+      case 'first.purchase':
+      case 'daily.login':
+        if (!payload.perkId) {
+          return { granted: false, reason: 'perkId required for event reward' };
+        }
+        return this.rewardEngine.earnPerk({
+          userId: payload.userId,
+          perkId: payload.perkId,
+          quantity: payload.quantity || 1,
+          source: `event:${event}`,
+        });
+
+      case 'admin.promotional.grant':
+        if (!payload.perkId || !payload.grantedBy) {
+          throw new BadRequestException('perkId and grantedBy are required for promotional grants');
+        }
+        return this.rewardEngine.grantPromotionalPerk({
+          userId: payload.userId,
+          perkId: payload.perkId,
+          quantity: payload.quantity || 1,
+          grantedBy: payload.grantedBy,
+        });
+
+      default:
+        return { granted: false, reason: 'Unsupported event' };
+    }
+  }
+}

backend/src/modules/monetization/rewards/rewardEngine.spec.ts

@@ -0,0 +1,80 @@
+import { BadRequestException } from '@nestjs/common';
+import { RewardEngine } from './rewardEngine';
+
+describe('RewardEngine', () => {
+  let engine: RewardEngine;
+
+  const inventoryService = {
+    addPerksToInventory: jest.fn(),
+  };
+
+  const perksService = {
+    findOnePublic: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    perksService.findOnePublic.mockResolvedValue({ id: 1, price: '10.00' });
+    engine = new RewardEngine(inventoryService as any, perksService as any);
+  });
+
+  it('buys a perk using server-side price', async () => {
+    const result = await engine.buyPerk({
+      userId: 42,
+      perkId: 1,
+      quantity: 2,
+      availableCurrency: 30,
+      clientUnitPrice: 10,
+    });
+
+    expect(result).toEqual({
+      purchased: true,
+      totalCost: 20,
+      remainingCurrency: 10,
+    });
+    expect(inventoryService.addPerksToInventory).toHaveBeenCalledWith(42, [{ perkId: 1, quantity: 2 }]);
+  });
+
+  it('rejects client-side price mismatch', async () => {
+    await expect(
+      engine.buyPerk({
+        userId: 42,
+        perkId: 1,
+        quantity: 1,
+        availableCurrency: 100,
+        clientUnitPrice: 1,
+      }),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it('rejects insufficient currency', async () => {
+    await expect(
+      engine.buyPerk({
+        userId: 42,
+        perkId: 1,
+        quantity: 2,
+        availableCurrency: 5,
+      }),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it('rate limits excessive purchase attempts', async () => {
+    for (let i = 0; i < 10; i += 1) {
+      await engine.buyPerk({
+        userId: 99,
+        perkId: 1,
+        quantity: 1,
+        availableCurrency: 999,
+      });
+    }
+
+    await expect(
+      engine.buyPerk({
+        userId: 99,
+        perkId: 1,
+        quantity: 1,
+        availableCurrency: 999,
+      }),
+    ).rejects.toThrow(BadRequestException);
+  });
+});