PMS — Multi-Tenant Portfolio Management Platform

PMS/
├── apps/
│   ├── backend/         # NestJS API (Port 3001)
│   │   └── src/
│   │       ├── auth/    # JWT, 2FA, Roles
│   │       ├── tenant/  # Multi-tenancy
│   │       ├── user/   # User management
│   │       ├── portfolio/
│   │       ├── course/  # LMS
│   │       ├── product/
│   │       ├── service/
│   │       ├── booking/
│   │       ├── payment/ # Razorpay
│   │       └── ai/     # AI services
│   └── frontend/       # Next.js 16 (Port 3000)
│       ├── app/
│       │   ├── (auth)/  # Login, Register
│       │   ├── (dashboard)/ # Main app
│       │   ├── (admin)/ # Admin panel
│       │   ├── learn/   # Course player
│       │   ├── p/       # Public portfolio
│       │   └── developer/ # Developer tools
│       └── components/
├── docker-compose.yml
└── scripts/             # Deployment & utilities

// backend/src/common/guards/tenant.guard.ts
@Injectable()
export class TenantGuard implements CanActivate {
  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const user = request.user;
    
    if (!user?.tenantId) {
      throw new UnauthorizedException('Tenant context required');
    }
    
    // Attach tenant ID to request for downstream use
    request.tenantId = user.tenantId;
    
    return true;
  }
}

// Prisma query with tenant scope
const products = await prisma.product.findMany({
  where: {
    tenantId: request.tenantId,
    ...filters
  }
});

// auth.service.ts
async generateTokens(user: User) {
  const payload = { 
    sub: user.id, 
    email: user.email, 
    role: user.role,
    tenantId: user.tenantId 
  };
  
  const accessToken = this.jwtService.sign(payload, {
    expiresIn: '15m',
    secret: process.env.JWT_SECRET
  });
  
  const refreshToken = this.jwtService.sign(payload, {
    expiresIn: '7d',
    secret: process.env.JWT_REFRESH_SECRET
  });
  
  // Store refresh token hash for verification
  await this.redis.set(`refresh:${user.id}`, 
    await bcrypt.hash(refreshToken, 10), 
    60 * 60 * 24 * 7
  );
  
  return { accessToken, refreshToken };
}

// course.service.ts
async markLessonComplete(userId: string, lessonId: string) {
  const progress = await prisma.courseProgress.create({
    data: {
      userId,
      lessonId,
      completedAt: new Date(),
    }
  });
  
  // Check if module is complete
  const moduleLessons = await prisma.lesson.findMany({
    where: { moduleId: progress.lesson.moduleId }
  });
  
  const completedCount = await prisma.courseProgress.count({
    where: {
      userId,
      lesson: { moduleId: progress.lesson.moduleId }
    }
  });
  
  if (completedCount === moduleLessons.length) {
    await this.completeModule(userId, progress.lesson.moduleId);
  }
  
  return progress;
}

// ai/loshu.service.ts
async function calculateLoShuGrid(dob: string): Promise<LoShuResult> {
  const digits = extractDigits(dob);
  const grid = buildLoShuGrid(digits);
  
  // Calculate career line (sum of specific cells)
  const career = grid[0] + grid[2] + grid[4] + grid[6] + grid[8];
  const health = grid[2] + grid[4] + grid[6];
  const emotions = grid[1] + grid[3] + grid[5] + grid[7];
  
  // Identify missing numbers
  const missing = findMissingNumbers(grid);
  
  // Generate personality insights
  const personality = generatePersonalityInsight(grid, missing);
  
  return {
    grid,
    career,
    health,
    emotions,
    missing,
    personality,
    favorableNumbers: findFavorableNumbers(grid),
    unfavorableNumbers: findUnfavorableNumbers(grid),
  };
}

// payment.service.ts
async function createOrder(amount: number, currency: string = 'INR') {
  const razorpay = new Razorpay({
    key_id: process.env.RAZORPAY_KEY_ID,
    key_secret: process.env.RAZORPAY_KEY_SECRET,
  });
  
  const order = await razorpay.orders.create({
    amount: amount * 100, // Convert to paise
    currency,
    receipt: `order_${Date.now()}`,
    payment_capture: 1,
  });
  
  return order;
}

async function verifyWebhook(payload: string, signature: string) {
  const expected = crypto
    .createHmac('sha256', process.env.RAZORPAY_WEBHOOK_SECRET)
    .update(payload)
    .digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

// Lo Shu Grid Structure
{
  4: 9: 2
  3: 5: 7
  8: 1: 6
  
  // Positions: Career, Friends, Family, etc.
  // Missing numbers indicate weaknesses
  // Repeated numbers indicate strengths
}

Course
├── Modules
│   ├── Lessons
│   │   ├── Video Content
│   │   ├── Text/Markdown
│   │   ├── Quiz
│   │   └── Discussion
│   └── Module Quiz
└── Final Assessment

// certificate.service.ts
async function generateCertificate(userId: string, courseId: string) {
  const course = await prisma.course.findUnique({ where: { id: courseId }});
  const user = await prisma.user.findUnique({ where: { id: userId }});
  
  // Calculate completion percentage
  const progress = await this.getCourseProgress(userId, courseId);
  
  if (progress < 100) {
    throw new BadRequestException('Course not completed');
  }
  
  // Generate PDF certificate
  const pdf = await this.pdfGenerator.generate({
    userName: user.name,
    courseName: course.title,
    completionDate: new Date(),
    certificateId: `CERT-${Date.now()}`,
  });
  
  return pdf;
}

# Start infrastructure
docker compose up -d

# Run migrations
npm run prisma:migrate

# Seed system
npm run seed

# Start apps
npm run dev

# Deploy to production
./scripts/full_deploy.ps1