Browse the data

1from fastapi import FastAPI, HTTPException, Header
2from pydantic import BaseModel
3from typing import Optional, List
4from datetime import datetime, timedelta
5import uuid
6import hashlib
7import hmac
8import json
9import calendar
10 
11app = FastAPI()
12 
13# In-memory storage
14users = {}
15tokens = {}
16subscriptions = {}
17subscription_id_counter = 1
18user_id_counter = 1
19 
20# Simple token generation
21def generate_token(user_id):
22    token = str(uuid.uuid4())
23    tokens[token] = user_id
24    return token
25 
26def get_user_id_from_token(authorization: str = Header(None)):
27    if not authorization or not authorization.startswith("Bearer "):
28        raise HTTPException(status_code=401, detail="Invalid auth header")
29    token = authorization.split(" ")[1]
30    user_id = tokens.get(token)
31    if not user_id:
32        raise HTTPException(status_code=401, detail="Invalid token")
33    return user_id
34 
35class SignupRequest(BaseModel):
36    email: str
37    password: str
38 
39class LoginRequest(BaseModel):
40    email: str
41    password: str
42 
43class CreateSubscriptionRequest(BaseModel):
44    user_id: int
45    plan_tier: str
46    payment_method: str
47    billing_address: str
48    coupon_code: Optional[str] = None
49 
50class UpdateSubscriptionRequest(BaseModel):
51    plan_tier: Optional[str] = None
52    payment_method: Optional[str] = None
53    billing_address: Optional[str] = None
54    coupon_code: Optional[str] = None
55 
56@app.post("/signup")
57def signup(req: SignupRequest):
58    global user_id_counter
59    user_id = user_id_counter
60    user_id_counter += 1
61    users[user_id] = {"email": req.email, "password": req.password, "id": user_id}
62    token = generate_token(user_id)
63    return {"user_id": user_id, "token": token}
64 
65@app.post("/login")
66def login(req: LoginRequest):
67    for uid, u in users.items():
68        if u["email"] == req.email and u["password"] == req.password:
69            token = generate_token(uid)
70            return {"user_id": uid, "token": token}
71    raise HTTPException(status_code=401, detail="Invalid credentials")
72 
73@app.get("/users/{user_id}")
74def get_user(user_id: int, authorization: str = Header(None)):
75    get_user_id_from_token(authorization)
76    user = users.get(user_id)
77    if not user:
78        raise HTTPException(status_code=404, detail="User not found")
79    return user
80 
81@app.post("/users")
82def create_user(req: SignupRequest):
83    return signup(req)
84 
85@app.post("/subscriptions")
86def create_subscription(req: CreateSubscriptionRequest, authorization: str = Header(None)):
87    global subscription_id_counter
88    get_user_id_from_token(authorization)
89    user = users.get(req.user_id)
90    if not user:
91        raise HTTPException(status_code=404, detail="User not found")
92    
93    # Check for existing active subscription
94    for sub_id, sub in subscriptions.items():
95        if sub["user_id"] == req.user_id and sub["status"] == "active":
96            raise HTTPException(status_code=400, detail="User already has an active subscription")
97    
98    sub_id = subscription_id_counter
99    subscription_id_counter += 1
100    
101    # Calculate prorated charge (simplified: 30 day month, prorate based on remaining days)
102    now = datetime.utcnow()
103    current_day = now.day
104    days_in_month = calendar.monthrange(now.year, now.month)[1]
105    remaining_days = days_in_month - current_day + 1
106    monthly_price = {"basic": 10.0, "pro": 25.0, "enterprise": 100.0}.get(req.plan_tier, 10.0)
107    prorated_amount = round((monthly_price / days_in_month) * remaining_days, 2)
108    
109    # Apply coupon if provided
110    coupon_discount = 0.0
111    if req.coupon_code:
112        # Simple coupon logic: 10% off for "SAVE10", $5 off for "FIVE"
113        if req.coupon_code == "SAVE10":
114            coupon_discount = round(prorated_amount * 0.1, 2)
115        elif req.coupon_code == "FIVE":
116            coupon_discount = 5.0
117        prorated_amount = max(0, prorated_amount - coupon_discount)
118    
119    subscriptions[sub_id] = {
120        "id": sub_id,
121        "user_id": req.user_id,
122        "plan_tier": req.plan_tier,
123        "payment_method": req.payment_method,
124        "billing_address": req.billing_address,
125        "coupon_code": req.coupon_code,
126        "status": "active",
127        "created_at": now.isoformat(),
128        "next_billing_date": (now + timedelta(days=30)).isoformat(),
129        "prorated_charge": prorated_amount,
130        "original_price": monthly_price
131    }
132    return subscriptions[sub_id]
133 
134@app.get("/subscriptions/{subscription_id}")
135def get_subscription(subscription_id: int, authorization: str = Header(None)):
136    get_user_id_from_token(authorization)
137    sub = subscriptions.get(subscription_id)
138    if not sub:
139        raise HTTPException(status_code=404, detail="Subscription not found")
140    return sub
141 
142@app.put("/subscriptions/{subscription_id}")
143def update_subscription(subscription_id: int, req: UpdateSubscriptionRequest, authorization: str = Header(None)):
144    user_id = get_user_id_from_token(authorization)
145    sub = subscriptions.get(subscription_id)
146    if not sub:
147        raise HTTPException(status_code=404, detail="Subscription not found")
148    if sub["user_id"] != user_id:
149        raise HTTPException(status_code=403, detail="Not your subscription")
150    
151    if req.plan_tier is not None:
152        # Calculate prorated charge for plan change
153        old_price = {"basic": 10.0, "pro": 25.0, "enterprise": 100.0}.get(sub["plan_tier"], 10.0)
154        new_price = {"basic": 10.0, "pro": 25.0, "enterprise": 100.0}.get(req.plan_tier, 10.0)
155        now = datetime.utcnow()
156        current_day = now.day
157        days_in_month = calendar.monthrange(now.year, now.month)[1]
158        remaining_days = days_in_month - current_day + 1
159        daily_old = old_price / days_in_month
160        daily_new = new_price / days_in_month
161        prorated_charge = round((daily_new - daily_old) * remaining_days, 2)
162        
163        # Apply coupon if provided
164        if req.coupon_code:
165            if req.coupon_code == "SAVE10":
166                prorated_charge = round(prorated_charge * 0.9, 2)
167            elif req.coupon_code == "FIVE":
168                prorated_charge = max(0, prorated_charge - 5.0)
169        
170        sub["plan_tier"] = req.plan_tier
171        sub["prorated_charge"] = prorated_charge
172        sub["original_price"] = new_price
173    
174    if req.payment_method is not None:
175        sub["payment_method"] = req.payment_method
176    if req.billing_address is not None:
177        sub["billing_address"] = req.billing_address
178    if req.coupon_code is not None:
179        sub["coupon_code"] = req.coupon_code
180    
181    sub["updated_at"] = datetime.utcnow().isoformat()
182    return sub

1fastapi
2uvicorn