Microservices Architecture

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import httpx  # অন্য service কে call করার জন্য
import asyncio

app = FastAPI(title="Order Service")

# অন্য services এর URL — real এ এটা env variable থেকে আসবেন
PAYMENT_SERVICE_URL = "http://payment-service:8001"
INVENTORY_SERVICE_URL = "http://inventory-service:8002"

class OrderRequest(BaseModel):
    user_id: int
    product_id: int
    quantity: int
    total_amount: float

# In-memory DB (real এ PostgreSQL হবে)
orders_db = {}
order_counter = 1

@app.post("/orders")
async def create_order(order: OrderRequest):
    global order_counter
    async with httpx.AsyncClient() as client:
        # Step 1: Inventory check করুন
        inv_response = await client.get(
            f"{INVENTORY_SERVICE_URL}/check/{order.product_id}/{order.quantity}"
        )
        if inv_response.status_code != 200:
            raise HTTPException(400, "Insufficient inventory")

        # Step 2: Payment process করুন
        pay_response = await client.post(
            f"{PAYMENT_SERVICE_URL}/charge",
            json={"user_id": order.user_id, "amount": order.total_amount}
        )
        if pay_response.status_code != 200:
            raise HTTPException(402, "Payment failed")

    # Step 3: Order save করুন
    order_id = order_counter
    orders_db[order_id] = {"id": order_id, "status": "confirmed", **order.dict()}
    order_counter += 1

    return {"order_id": order_id, "status": "confirmed"}

@app.get("/orders/{order_id}")
async def get_order(order_id: int):
    order = orders_db.get(order_id)
    if not order:
        raise HTTPException(404, "Order not found")
    return order

const express = require('express');
const app = express();
app.use(express.json());

// Mock payment processor
const payments = new Map();

app.post('/charge', async (req, res) => {
    const { user_id, amount } = req.body;

    // Simulate payment processing
    if (amount <= 0) {
        return res.status(400).json({ error: 'Invalid amount' });
    }

    const payment_id = `pay_${Date.now()}`;
    payments.set(payment_id, {
        user_id,
        amount,
        status: 'success',
        timestamp: new Date().toISOString()
    });

    // Real এ এখানে Stripe/bKash API call হবে
    res.json({
        payment_id,
        status: 'success',
        message: `Payment of ৳${amount} processed`
    });
});

app.get('/payment/:id', (req, res) => {
    const payment = payments.get(req.params.id);
    if (!payment) return res.status(404).json({ error: 'Not found' });
    res.json(payment);
});

app.listen(8001, () => console.log('Payment service running on :8001'));

version: '3.8'
services:
  api-gateway:
    image: nginx:alpine
    ports: ["80:80"]
    volumes: ["./nginx.conf:/etc/nginx/nginx.conf"]
    depends_on: [order-service, payment-service, inventory-service]

  order-service:
    build: ./order_service
    ports: ["8000:8000"]
    environment:
      - DATABASE_URL=postgresql://user:pass@order-db:5432/orders
    depends_on: [order-db, kafka]

  payment-service:
    build: ./payment_service
    ports: ["8001:8001"]

  inventory-service:
    build: ./inventory_service
    ports: ["8002:8002"]

  order-db:
    image: postgres:15
    environment:
      POSTGRES_DB: orders
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass

  kafka:
    image: confluentinc/cp-kafka:latest
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181