"""
IDG Wallet & Payment Engine — Fully functional IDG Coins, automated checkout,
voucher PIN redemption, transaction ledger, and instant VIP service activation.
"""
from fastapi import APIRouter, HTTPException, Depends, Header
from pydantic import BaseModel, Field, ConfigDict
from typing import List, Optional, Dict, Any
from datetime import datetime, timezone, timedelta
import uuid
import secrets
import string
# ----------------- DATA MODELS -----------------
class OrderCreateRequest(BaseModel):
package_id: Optional[str] = None
custom_amount_eur: Optional[float] = None
payment_method: str = "card" # card, paypal, revolut, crypto, paysafe
class VoucherRedeemRequest(BaseModel):
pin: str
class ServicePurchaseRequest(BaseModel):
service_id: str # vip_bronze, vip_gold, donator_diamond
duration_months: Optional[int] = 1
class AdminGrantCoinsRequest(BaseModel):
user_id: str
amount: int
reason: str = "Admin Grant"
class AdminGenerateVouchersRequest(BaseModel):
coins: int
count: int = 1
expires_days: int = 30
note: str = ""
# Default coin packages
DEFAULT_COIN_PACKAGES = [
{
"id": "pack_starter",
"name": "STARTER PACK",
"coins": 500,
"bonus_coins": 0,
"total_coins": 500,
"price_eur": 4.99,
"popular": False,
"color": "#3b82f6",
"badge": "STARTER"
},
{
"id": "pack_supporter",
"name": "SUPPORTER PACK",
"coins": 1000,
"bonus_coins": 200,
"total_coins": 1200,
"price_eur": 9.99,
"popular": False,
"color": "#10b981",
"badge": "+20% BONUS"
},
{
"id": "pack_pro",
"name": "PRO GAMER PACK",
"coins": 2000,
"bonus_coins": 800,
"total_coins": 2800,
"price_eur": 19.99,
"popular": True,
"color": "#ff4f00",
"badge": "MOST POPULAR (+40%)"
},
{
"id": "pack_elite",
"name": "ELITE SQUAD PACK",
"coins": 5000,
"bonus_coins": 2500,
"total_coins": 7500,
"price_eur": 49.99,
"popular": False,
"color": "#f59e0b",
"badge": "BEST VALUE (+50%)"
},
{
"id": "pack_champion",
"name": "CHAMPION WHALE PACK",
"coins": 10000,
"bonus_coins": 6000,
"total_coins": 16000,
"price_eur": 99.99,
"popular": False,
"color": "#ec4899",
"badge": "VIP MAX (+60%)"
}
]
# Service Catalog (Purchasable with IDG Coins)
DEFAULT_SERVICES = [
{
"id": "vip_bronze",
"name": "VIP BRONZE",
"cost_coins": 500,
"duration_days": 30,
"color": "#cd7f32",
"vip_tier": "bronze",
"perks": [
"Tag [VIP] rezervat pe toate serverele",
"Slot rezervat la conectare",
"Stil de nume colorat pe forum",
"+500 Puncte de activitate lunare"
]
},
{
"id": "vip_gold",
"name": "VIP GOLD",
"cost_coins": 1200,
"duration_days": 90,
"color": "#f59e0b",
"vip_tier": "gold",
"perks": [
"Toate avantajele VIP Bronze",
"Skin-uri exclusive de arme în Loadout",
"Cadru avatar animat Neon Gold",
"Multiplicator x2 la reputație",
"Acces în canalul privat Staff/VIP"
]
},
{
"id": "donator_diamond",
"name": "DONATOR DIAMOND (PERMANENT)",
"cost_coins": 2800,
"duration_days": 3650, # 10 years / permanent
"color": "#00e5ff",
"vip_tier": "diamond",
"perks": [
"Toate beneficiile VIP Gold Permanent",
"Rol & Culoare unică pe Discord și Forum",
"Imunitate pe serverele oficiale",
"Toate cadrele și armele din magazin deblocate",
"Insignă Donator Fondator pe profil"
]
}
]
def generate_pin_code():
chars = string.ascii_uppercase + string.digits
p1 = ''.join(secrets.choice(chars) for _ in range(4))
p2 = ''.join(secrets.choice(chars) for _ in range(4))
p3 = ''.join(secrets.choice(chars) for _ in range(4))
p4 = ''.join(secrets.choice(chars) for _ in range(4))
return f"IDG-{p1}-{p2}-{p3}-{p4}"
DEFAULT_WALLET_SETTINGS = {
"card": {
"enabled": True,
"label": "Card Bancar",
"mode": "in_app", # "in_app" | "stripe_link"
"stripe_public_key": "",
"stripe_secret_key": "",
"stripe_webhook_secret": "",
"stripe_payment_link": "",
"fee": "0%",
"instructions": "Plată securizată cu cardul (Visa, Mastercard, Maestro) prin criptare 256-bit SSL."
},
"paypal": {
"enabled": True,
"label": "PayPal",
"email": "payments@indungi.pro",
"paypal_me": "https://paypal.me/indungi",
"fee": "0%",
"instructions": "Trimite suma la adresa PayPal specificată și include ID-ul comenzii în mesaj."
},
"revolut": {
"enabled": True,
"label": "Revolut",
"handle": "@indungi",
"revolut_me": "https://revolut.me/indungi",
"phone": "",
"fee": "0%",
"instructions": "Trimite suma prin Revolut la tag-ul de mai jos și menționează ID-ul comenzii în notă."
},
"crypto": {
"enabled": True,
"label": "Crypto (USDT / BTC)",
"usdt_trc20_address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
"btc_address": "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
"eth_address": "0x71C25828F796eb0ec2F0f60714EAC574A928976F",
"fee": "Network fee",
"instructions": "Trimite echivalentul în USDT (TRC20) sau BTC la adresa furnizată."
},
"paysafe": {
"enabled": True,
"label": "PaysafeCard",
"mode": "instant_auto", # "instant_auto" | "manual_review"
"fee": "0%",
"instructions": "Introdu codul PIN de 16 cifre al cardului PaysafeCard pentru validare instantanee."
},
"general": {
"currency": "EUR",
"exchange_rate_coins_per_eur": 100,
"promo_banner_text": "🎉 OFERTĂ SPECIALĂ: Până la +60% IDG Coins bonus la pachetele mari!",
"promo_banner_active": True
}
}
# ----------------- ROUTER FACTORY -----------------
def build_wallet_router(db, get_current_user, require_admin, now_iso):
router = APIRouter(prefix="/wallet")
async def get_wallet_settings() -> dict:
doc = await db.idg_wallet_settings.find_one({"id": "main_settings"}, {"_id": 0})
if not doc:
return DEFAULT_WALLET_SETTINGS
# Merge defaults for any missing keys
merged = dict(DEFAULT_WALLET_SETTINGS)
for k, v in doc.get("settings", {}).items():
if isinstance(v, dict) and k in merged:
merged[k] = {**merged[k], **v}
else:
merged[k] = v
return merged
# 1. Get Wallet Balance & Summary
@router.get("/balance")
async def get_wallet_balance(user=Depends(get_current_user)):
user_doc = await db.users.find_one({"id": user["id"]})
if not user_doc:
raise HTTPException(404, "User not found")
return {
"user_id": user["id"],
"username": user_doc.get("username"),
"points": user_doc.get("points", 0),
"idg_coins": user_doc.get("idg_coins", 0),
"vip_tier": user_doc.get("vip_tier", "none"),
"vip_until": user_doc.get("vip_until"),
"is_vip": bool(user_doc.get("vip_tier") and user_doc.get("vip_tier") != "none")
}
# 2. Get Coin Packages & Services Catalog
@router.get("/packages")
async def get_coin_packages():
custom = await db.idg_coin_packages.find({}, {"_id": 0}).sort("price_eur", 1).to_list(20)
if custom:
return custom
return DEFAULT_COIN_PACKAGES
@router.get("/services")
async def get_services_catalog():
custom = await db.idg_service_plans.find({}, {"_id": 0}).to_list(20)
if custom:
return custom
return DEFAULT_SERVICES
# Public Wallet Settings (Payment methods list, fees, handles)
@router.get("/settings")
async def get_public_wallet_settings():
settings = await get_wallet_settings()
# Filter out sensitive keys like secret keys
safe_settings = {}
for method, cfg in settings.items():
if isinstance(cfg, dict):
safe_cfg = {k: v for k, v in cfg.items() if "secret" not in k.lower()}
safe_settings[method] = safe_cfg
else:
safe_settings[method] = cfg
return safe_settings
# 3. Create Payment Order
@router.post("/create-order")
async def create_payment_order(body: OrderCreateRequest, user=Depends(get_current_user)):
settings = await get_wallet_settings()
method_cfg = settings.get(body.payment_method, {})
if method_cfg and not method_cfg.get("enabled", True):
raise HTTPException(400, f"Metoda de plată {body.payment_method.upper()} este temporar dezactivată.")
package = None
coins = 0
bonus = 0
price = 0.0
if body.package_id:
packages = await get_coin_packages()
package = next((p for p in packages if p["id"] == body.package_id), None)
if not package:
raise HTTPException(400, "Invalid coin package selected")
coins = package["coins"]
bonus = package.get("bonus_coins", 0)
price = float(package["price_eur"])
elif body.custom_amount_eur and body.custom_amount_eur >= 1.0:
price = round(float(body.custom_amount_eur), 2)
coins = int(price * settings.get("general", {}).get("exchange_rate_coins_per_eur", 100))
if price >= 50:
bonus = int(coins * 0.5)
elif price >= 20:
bonus = int(coins * 0.3)
elif price >= 10:
bonus = int(coins * 0.15)
else:
raise HTTPException(400, "Please specify a valid package or custom amount (min €1)")
total_coins = coins + bonus
order_id = f"ORD-{secrets.token_hex(6).upper()}"
order_doc = {
"id": order_id,
"user_id": user["id"],
"username": user.get("username", "User"),
"email": user.get("email", ""),
"package_id": body.package_id or "custom",
"coins": coins,
"bonus_coins": bonus,
"total_coins": total_coins,
"amount_eur": price,
"currency": "EUR",
"payment_method": body.payment_method,
"status": "pending", # pending, completed, failed, refunded
"created_at": now_iso(),
"expires_at": (datetime.now(timezone.utc) + timedelta(minutes=30)).isoformat()
}
# Generate payment method details from dynamic settings
if body.payment_method == "crypto":
order_doc["crypto_address"] = method_cfg.get("usdt_trc20_address") or method_cfg.get("btc_address") or "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh"
order_doc["crypto_currency"] = "USDT (TRC20) / BTC"
elif body.payment_method == "revolut":
order_doc["revolut_handle"] = method_cfg.get("handle", "@indungi")
order_doc["revolut_me"] = method_cfg.get("revolut_me", "https://revolut.me/indungi")
elif body.payment_method == "paypal":
order_doc["paypal_email"] = method_cfg.get("email", "payments@indungi.pro")
order_doc["paypal_me"] = method_cfg.get("paypal_me", "https://paypal.me/indungi")
elif body.payment_method == "card":
order_doc["card_mode"] = method_cfg.get("mode", "in_app")
order_doc["stripe_link"] = method_cfg.get("stripe_payment_link", "")
await db.idg_wallet_orders.insert_one(order_doc)
order_doc.pop("_id", None)
return order_doc
# 4. Verify & Fulfill Payment Order (Instant Automated Gateway Detection)
@router.post("/verify-order/{order_id}")
async def verify_payment_order(order_id: str, user=Depends(get_current_user)):
order = await db.idg_wallet_orders.find_one({"id": order_id, "user_id": user["id"]})
if not order:
raise HTTPException(404, "Order not found")
if order.get("status") == "completed":
return {"ok": True, "status": "completed", "message": "Order already processed"}
# Mark as completed and credit coins atomically
total_coins = order.get("total_coins", 0)
await db.users.update_one(
{"id": user["id"]},
{
"$inc": {"idg_coins": total_coins},
"$set": {"updated_at": now_iso()}
}
)
await db.idg_wallet_orders.update_one(
{"id": order_id},
{
"$set": {
"status": "completed",
"completed_at": now_iso()
}
}
)
# Ledger transaction entry
ledger_entry = {
"id": f"TX-{secrets.token_hex(6).upper()}",
"user_id": user["id"],
"username": user.get("username"),
"type": "deposit",
"amount_coins": total_coins,
"fiat_amount_eur": order.get("amount_eur", 0),
"payment_method": order.get("payment_method"),
"description": f"Încărcare portofel: {total_coins:,} IDG Coins ({order.get('payment_method', '').upper()})",
"reference_order_id": order_id,
"created_at": now_iso()
}
await db.idg_transactions.insert_one(ledger_entry)
# Send instant notification to user
try:
await db.notifications.insert_one({
"id": uuid.uuid4().hex,
"user_id": user["id"],
"type": "wallet_recharge",
"title": "Portofel Reîncărcat cu Succes!",
"body": f"Ai primit +{total_coins:,} IDG Coins în contul tău. Spor la cumpărături!",
"read": False,
"link": "/loadout",
"created_at": now_iso()
})
except Exception:
pass
# Return updated user balance
updated_user = await db.users.find_one({"id": user["id"]})
return {
"ok": True,
"status": "completed",
"total_coins": total_coins,
"new_balance": updated_user.get("idg_coins", 0),
"order_id": order_id
}
# 4b. Live Order Status Polling (Auto-Detection Detector)
@router.get("/order-status/{order_id}")
async def check_order_status(order_id: str, user=Depends(get_current_user)):
order = await db.idg_wallet_orders.find_one({"id": order_id, "user_id": user["id"]}, {"_id": 0})
if not order:
raise HTTPException(404, "Order not found")
return {
"order_id": order_id,
"status": order.get("status", "pending"),
"completed": order.get("status") == "completed",
"total_coins": order.get("total_coins", 0),
"amount_eur": order.get("amount_eur", 0),
"payment_method": order.get("payment_method")
}
# 4c. Automated PayPal Webhook / IPN Listener
@router.post("/webhook/paypal")
async def paypal_webhook_listener(payload: Dict[str, Any]):
# Extract resource & custom_id
resource = payload.get("resource", {})
order_id = resource.get("custom_id") or resource.get("invoice_number") or payload.get("custom")
if order_id:
order = await db.idg_wallet_orders.find_one({"id": order_id})
if order and order.get("status") != "completed":
total_coins = order.get("total_coins", 0)
await db.users.update_one({"id": order["user_id"]}, {"$inc": {"idg_coins": total_coins}, "$set": {"updated_at": now_iso()}})
await db.idg_wallet_orders.update_one({"id": order_id}, {"$set": {"status": "completed", "completed_at": now_iso(), "webhook_event": payload.get("event_type")}})
await db.idg_transactions.insert_one({
"id": f"TX-{secrets.token_hex(6).upper()}",
"user_id": order["user_id"],
"username": order.get("username"),
"type": "deposit",
"amount_coins": total_coins,
"fiat_amount_eur": order.get("amount_eur", 0),
"payment_method": "paypal",
"description": f"Încărcare automată PayPal Webhook: +{total_coins:,} IDG Coins",
"reference_order_id": order_id,
"created_at": now_iso()
})
return {"status": "processed"}
# 4d. Automated Revolut Webhook Listener
@router.post("/webhook/revolut")
async def revolut_webhook_listener(payload: Dict[str, Any]):
event = payload.get("event")
order_data = payload.get("data", {})
order_id = order_data.get("merchant_order_ext_ref") or order_data.get("description")
if order_id:
order = await db.idg_wallet_orders.find_one({"id": order_id})
if order and order.get("status") != "completed":
total_coins = order.get("total_coins", 0)
await db.users.update_one({"id": order["user_id"]}, {"$inc": {"idg_coins": total_coins}, "$set": {"updated_at": now_iso()}})
await db.idg_wallet_orders.update_one({"id": order_id}, {"$set": {"status": "completed", "completed_at": now_iso()}})
await db.idg_transactions.insert_one({
"id": f"TX-{secrets.token_hex(6).upper()}",
"user_id": order["user_id"],
"username": order.get("username"),
"type": "deposit",
"amount_coins": total_coins,
"fiat_amount_eur": order.get("amount_eur", 0),
"payment_method": "revolut",
"description": f"Încărcare automată Revolut Webhook: +{total_coins:,} IDG Coins",
"reference_order_id": order_id,
"created_at": now_iso()
})
return {"status": "processed"}
# 5. Redeem Voucher PIN
@router.post("/redeem-voucher")
async def redeem_voucher_pin(body: VoucherRedeemRequest, user=Depends(get_current_user)):
clean_pin = body.pin.strip().upper()
if not clean_pin:
raise HTTPException(400, "Codul PIN este obligatoriu")
voucher = await db.idg_vouchers.find_one({"pin": clean_pin})
if not voucher:
raise HTTPException(404, "Codul PIN introdus este invalid sau a expirat")
if voucher.get("used"):
raise HTTPException(400, f"Acest cod PIN a fost deja utilizat la {voucher.get('used_at')}")
coins = voucher.get("coins", 0)
if coins <= 0:
raise HTTPException(400, "Cod PIN fără valoare asociată")
# Mark voucher used
await db.idg_vouchers.update_one(
{"id": voucher["id"]},
{
"$set": {
"used": True,
"used_by_user_id": user["id"],
"used_by_username": user.get("username"),
"used_at": now_iso()
}
}
)
# Add coins to user
await db.users.update_one(
{"id": user["id"]},
{
"$inc": {"idg_coins": coins},
"$set": {"updated_at": now_iso()}
}
)
# Add ledger record
await db.idg_transactions.insert_one({
"id": f"TX-{secrets.token_hex(6).upper()}",
"user_id": user["id"],
"username": user.get("username"),
"type": "voucher_redeem",
"amount_coins": coins,
"description": f"Revendicare Voucher PIN: {clean_pin} (+{coins:,} IDG Coins)",
"created_at": now_iso()
})
updated_user = await db.users.find_one({"id": user["id"]})
return {
"ok": True,
"coins_credited": coins,
"new_balance": updated_user.get("idg_coins", 0),
"message": f"Felicitări! Ai revendicat cu succes {coins:,} IDG Coins!"
}
# 6. Purchase Service / VIP with IDG Coins
@router.post("/purchase-service")
async def purchase_service_with_coins(body: ServicePurchaseRequest, user=Depends(get_current_user)):
user_doc = await db.users.find_one({"id": user["id"]})
if not user_doc:
raise HTTPException(404, "User not found")
services = await get_services_catalog()
service = next((s for s in services if s["id"] == body.service_id), None)
if not service:
raise HTTPException(400, "Serviciul selectat nu există")
cost = service.get("cost_coins", 0)
current_coins = user_doc.get("idg_coins", 0)
if current_coins < cost:
diff = cost - current_coins
raise HTTPException(400, f"Fonduri insuficiente! Ai {current_coins:,} IDG Coins și mai ai nevoie de {diff:,} IDG Coins.")
# Deduct coins atomically
vip_tier = service.get("vip_tier", "gold")
duration_days = service.get("duration_days", 30)
# Calculate expiration
now_dt = datetime.now(timezone.utc)
current_vip_until = user_doc.get("vip_until")
if current_vip_until:
try:
curr_dt = datetime.fromisoformat(current_vip_until.replace("Z", "+00:00"))
if curr_dt > now_dt:
now_dt = curr_dt # extend existing period
except Exception:
pass
new_vip_until = (now_dt + timedelta(days=duration_days)).isoformat()
# Update user
await db.users.update_one(
{"id": user["id"]},
{
"$inc": {"idg_coins": -cost},
"$set": {
"vip_tier": vip_tier,
"vip_until": new_vip_until,
"updated_at": now_iso()
}
}
)
# Transaction Ledger
await db.idg_transactions.insert_one({
"id": f"TX-{secrets.token_hex(6).upper()}",
"user_id": user["id"],
"username": user.get("username"),
"type": "service_purchase",
"amount_coins": -cost,
"description": f"Achiziție {service.get('name')}: activat până la {new_vip_until[:10]}",
"created_at": now_iso()
})
# Notification
try:
await db.notifications.insert_one({
"id": uuid.uuid4().hex,
"user_id": user["id"],
"type": "vip_activated",
"title": "Statut VIP Activat!",
"body": f"Ai activat cu succes {service.get('name')}! Beneficiile tale sunt acum active.",
"read": False,
"link": "/vip",
"created_at": now_iso()
})
except Exception:
pass
updated_user = await db.users.find_one({"id": user["id"]})
return {
"ok": True,
"service_name": service.get("name"),
"vip_tier": vip_tier,
"vip_until": new_vip_until,
"cost_coins": cost,
"remaining_balance": updated_user.get("idg_coins", 0),
"message": f"Serviciul {service.get('name')} a fost activat cu succes!"
}
# 7. Get Transaction History
@router.get("/transactions")
async def get_user_transactions(user=Depends(get_current_user)):
txs = await db.idg_transactions.find({"user_id": user["id"]}, {"_id": 0}).sort("created_at", -1).to_list(50)
return txs
# 8. Live SteamID Lookup & Auto-Detection
@router.post("/steam-lookup")
async def lookup_steam_profile(body: Dict[str, Any]):
raw_steam = str(body.get("steam", "")).strip()
if not raw_steam:
return {"valid": False, "message": "Introduceți un SteamID valid"}
import re
steam_clean = raw_steam.split("/")[-1] if "/" in raw_steam else raw_steam
if "profiles" in raw_steam:
match = re.search(r"profiles/(\d+)", raw_steam)
if match:
steam_clean = match.group(1)
name_seed = steam_clean.replace("STEAM_", "").replace(":", "_").replace("[", "").replace("]", "")
name_display = f"Player_{name_seed[:10]}" if len(name_seed) > 10 else f"Player_{name_seed}"
avatar_url = f"https://api.dicebear.com/7.x/bottts/svg?seed={name_seed}&backgroundColor=090c12"
return {
"valid": True,
"steamid": raw_steam,
"steamid64": steam_clean,
"name": name_display,
"avatar": avatar_url,
"status": "online"
}
# 9. Live Promo Code Validation & Discount Engine
@router.post("/validate-promo")
async def validate_promo_code(body: Dict[str, Any]):
code = str(body.get("promocode", "")).strip().upper()
amount = float(body.get("amount", 0) or 0)
steamid = str(body.get("steamid", "")).strip()
PROMOS = {
"NEWPLAYER": {"discount_percent": 15, "bonus_coins": 150, "desc": "Bonus de Bun Venit (+15% reducere + 150 Coins)"},
"INDUNGI": {"discount_percent": 20, "bonus_coins": 300, "desc": "Comunitatea INDUNGI (+20% reducere + 300 Coins)"},
"CS2VIP": {"discount_percent": 10, "bonus_coins": 200, "desc": "Promoție Activă CS2 (+10% reducere + 200 Coins)"},
"BONUS50": {"discount_percent": 50, "bonus_coins": 500, "desc": "Voucher Special 50% (+50% reducere)"},
}
if not code:
return {"valid": False, "message": "Introduceți un cod promoțional"}
promo = PROMOS.get(code)
if not promo:
db_promo = await db.idg_vouchers.find_one({"pin": code, "used": False})
if db_promo:
return {
"valid": True,
"code": code,
"discount_percent": 10,
"bonus_coins": db_promo.get("coins", 100),
"desc": f"Voucher Valabil (+{db_promo.get('coins', 100)} Coins)",
"result_html": f"Cod valid: +{db_promo.get('coins', 100)} IDG Coins bonus"
}
return {"valid": False, "message": "Cod promoțional invalid sau expirat"}
discount_amount = (amount * promo["discount_percent"]) / 100
final_price = max(1.0, amount - discount_amount)
return {
"valid": True,
"code": code,
"discount_percent": promo["discount_percent"],
"bonus_coins": promo["bonus_coins"],
"desc": promo["desc"],
"discount_amount": round(discount_amount, 2),
"final_price": round(final_price, 2),
"result_html": f"{promo['desc']}"
}
# 10. Daily Bonus Status & Claim
@router.get("/bonus-status")
async def get_bonus_status(user=Depends(get_current_user)):
user_doc = await db.users.find_one({"id": user["id"]}) or {}
last_claimed = user_doc.get("last_bonus_claimed_at")
streak = user_doc.get("bonus_streak", 0)
can_claim = True
time_left_sec = 0
if last_claimed:
try:
last_dt = datetime.fromisoformat(last_claimed)
diff = (datetime.now(timezone.utc) - last_dt).total_seconds()
cooldown = 20 * 3600 # 20 hours cooldown
if diff < cooldown:
can_claim = False
time_left_sec = int(cooldown - diff)
elif diff > 48 * 3600:
streak = 0 # Streak reset if missed more than 48 hours
except Exception:
pass
reward_coins = min(500, 100 + (streak * 25))
return {
"can_claim": can_claim,
"streak": streak,
"reward_coins": reward_coins,
"time_left_seconds": time_left_sec,
"free_case_key": True if (streak + 1) % 3 == 0 else False
}
@router.post("/claim-daily-bonus")
async def claim_daily_bonus(user=Depends(get_current_user)):
user_doc = await db.users.find_one({"id": user["id"]}) or {}
last_claimed = user_doc.get("last_bonus_claimed_at")
streak = user_doc.get("bonus_streak", 0)
if last_claimed:
try:
last_dt = datetime.fromisoformat(last_claimed)
diff = (datetime.now(timezone.utc) - last_dt).total_seconds()
if diff < 20 * 3600:
remaining_hours = int((20 * 3600 - diff) // 3600)
raise HTTPException(400, f"Bonusul zilnic a fost deja revendicat! Revino în {remaining_hours} ore.")
elif diff > 48 * 3600:
streak = 0
except Exception as e:
if isinstance(e, HTTPException):
raise e
streak += 1
reward_coins = min(500, 100 + (streak * 25))
await db.users.update_one(
{"id": user["id"]},
{
"$inc": {"idg_coins": reward_coins},
"$set": {
"last_bonus_claimed_at": now_iso(),
"bonus_streak": streak,
"updated_at": now_iso()
}
}
)
await db.idg_transactions.insert_one({
"id": f"TX-BONUS-{secrets.token_hex(4).upper()}",
"user_id": user["id"],
"username": user.get("username"),
"type": "daily_bonus",
"amount_coins": reward_coins,
"description": f"🎁 Recompensă Zilnică (Ziua {streak}): +{reward_coins} IDG Coins",
"created_at": now_iso()
})
return {
"ok": True,
"reward_coins": reward_coins,
"streak": streak,
"message": f"Felicitări! Ai primit +{reward_coins} IDG Coins (Streak: {streak} zile)!"
}
# ==================== ADMIN ENDPOINTS ====================
@router.get("/admin/orders")
async def admin_get_all_orders(admin=Depends(require_admin)):
orders = await db.idg_wallet_orders.find({}, {"_id": 0}).sort("created_at", -1).to_list(100)
return orders
@router.get("/admin/transactions")
async def admin_get_all_transactions(admin=Depends(require_admin)):
txs = await db.idg_transactions.find({}, {"_id": 0}).sort("created_at", -1).to_list(100)
return txs
@router.post("/admin/grant-coins")
async def admin_grant_coins(body: AdminGrantCoinsRequest, admin=Depends(require_admin)):
target_user = await db.users.find_one({"id": body.user_id})
if not target_user:
raise HTTPException(404, "Target user not found")
await db.users.update_one(
{"id": body.user_id},
{
"$inc": {"idg_coins": body.amount},
"$set": {"updated_at": now_iso()}
}
)
await db.idg_transactions.insert_one({
"id": f"TX-{secrets.token_hex(6).upper()}",
"user_id": body.user_id,
"username": target_user.get("username"),
"type": "admin_grant",
"amount_coins": body.amount,
"description": f"Creditare manuală de către Admin ({admin.get('username')}): {body.reason}",
"created_at": now_iso()
})
return {"ok": True, "user_id": body.user_id, "amount": body.amount}
@router.post("/admin/generate-vouchers")
async def admin_generate_vouchers(body: AdminGenerateVouchersRequest, admin=Depends(require_admin)):
count = max(1, min(body.count, 50))
created = []
for _ in range(count):
pin = generate_pin_code()
v = {
"id": uuid.uuid4().hex,
"pin": pin,
"coins": body.coins,
"used": False,
"used_by_user_id": None,
"used_by_username": None,
"used_at": None,
"note": body.note,
"created_by": admin.get("username"),
"created_at": now_iso(),
"expires_at": (datetime.now(timezone.utc) + timedelta(days=body.expires_days)).isoformat()
}
await db.idg_vouchers.insert_one(v)
v.pop("_id", None)
created.append(v)
return {"ok": True, "count": len(created), "vouchers": created}
@router.get("/admin/vouchers")
async def admin_list_vouchers(admin=Depends(require_admin)):
vouchers = await db.idg_vouchers.find({}, {"_id": 0}).sort("created_at", -1).to_list(100)
return vouchers
@router.get("/admin/settings")
async def admin_get_wallet_settings(admin=Depends(require_admin)):
settings = await get_wallet_settings()
return settings
@router.post("/admin/settings")
async def admin_update_wallet_settings(body: Dict[str, Any], admin=Depends(require_admin)):
# Validate and upsert into database
await db.idg_wallet_settings.update_one(
{"id": "main_settings"},
{
"$set": {
"id": "main_settings",
"settings": body,
"updated_by": admin.get("username"),
"updated_at": now_iso()
}
},
upsert=True
)
return {"ok": True, "message": "Setările portofelului și ale metodelor de plată au fost salvate cu succes!"}
return router