import asyncio from fastapi import FastAPI, Request, Depends, HTTPException, Form, Response, WebSocket, WebSocketDisconnect from fastapi.responses import FileResponse, HTMLResponse, RedirectResponse, JSONResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates from starlette.responses import FileResponse from starlette.types import Scope import os import mimetypes class CachedStaticFiles(StaticFiles): async def get_response(self, path: str, scope: Scope) -> FileResponse: response = await super().get_response(path, scope) if response.status_code == 200: ext = os.path.splitext(path)[1].lower() if ext in ('.css', '.js', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.woff2', '.webp'): response.headers['Cache-Control'] = 'public, max-age=86400' elif ext in ('.html',): response.headers['Cache-Control'] = 'no-cache' return response from sqlalchemy.orm import Session from sqlalchemy import desc from typing import Optional, List import json import random import math from datetime import datetime, timedelta from pathlib import Path import json from pathlib import Path from database import get_db, get_db_executor, get_async_db, AsyncSessionLocal, SessionLocal, AsyncSession, User, InventoryItem, CaseOpening, Contract, Upgrade, UpgradeRPU, PromoCode from websocket_manager import manager, crash_game from sqlalchemy import select, func as sa_func, desc from achievements import ( seed_achievements, check_achievement, check_open_cases_achievements, check_contracts_achievements, check_upgrade_achievements, check_upgrade_risk_achievements, check_upgrade_result_achievements, check_rare_item_achievement, check_knife_achievement, check_spent_achievements, check_balance_achievements, check_slot_match_achievements, check_slot_plays_achievements, check_slot_match_count_achievements, check_inventory_achievements, check_dildo_achievements, check_dildo_contract_achievement, check_crash_achievements, check_crash_cashout_achievements, check_items_unboxed_achievements, check_total_profit_achievements, check_achievements_count_achievements, check_rare_item_count_achievements, check_knife_count_achievements, check_midnight_case_achievement, check_exact_cases_achievement, check_collection_achievements, get_user_achievements ) from auth import ( create_user, authenticate_user, create_access_token, get_current_user, get_current_user_optional, get_password_hash, get_current_user_sync, get_current_user_optional_sync, ACCESS_TOKEN_EXPIRE_MINUTES, is_item_craftable ) from admin import admin_router import sys sys.path.append(str(Path(__file__).parent.parent)) from backend import ( ALL_ITEMS, get_item, ITEM_BY_ID, NAME_LOWER_TO_IDS, COLLECTIONS_INDEX, simulate_trade_up, calculate_average_float, RARITY_ORDER, get_rarity_level, is_knife, is_gloves, extract_base_name, get_possible_outcomes ) from upgrade import ( get_upgrade_rpu, calculate_upgrade_probability, get_adjusted_upgrade_probability, spin_upgrade_wheel, update_upgrade_stats, get_upgrade_rpu_async, get_adjusted_upgrade_probability_async, update_upgrade_stats_async ) from rpu import get_adjusted_weights, get_user_rpu, update_rpu_stats, RARITY_TO_FIELD from auth import get_password_hash # Создаем отдельное приложение для веб-интерфейса app = FastAPI(title="CS2 Trade-Up Simulator Web") app.include_router(admin_router) # Статические файлы и шаблоны app.mount("/static", CachedStaticFiles(directory="static"), name="static") templates = Jinja2Templates(directory="templates") def money_filter(value): try: return "{:,.0f}".format(float(value)).replace(",", " ") except (ValueError, TypeError): return "0" templates.env.filters["money"] = money_filter # Создаем отдельный роутер для API оригинального симулятора from backend import app as api_app # Монтируем оригинальное API на /api/simulator чтобы избежать конфликтов app.mount("/api/simulator", api_app) # ─── Pagination helper ───────────────────────────────────────────────────── DEFAULT_PAGE_SIZE = 50 def paginate(query, page: int = 1, page_size: int = DEFAULT_PAGE_SIZE): offset = (page - 1) * page_size return query.offset(offset).limit(page_size) def paginated_response(items, total: int, page: int, page_size: int = DEFAULT_PAGE_SIZE): return { "items": items, "total": total, "page": page, "page_size": page_size, "pages": max(1, (total + page_size - 1) // page_size), } # ─── Rate Limiting ────────────────────────────────────────────────────────── from collections import defaultdict import time _rate_limit_store: dict = defaultdict(list) RATE_LIMIT_WINDOW = 60 # seconds RATE_LIMIT_MAX_CASES = 30 # max case opens per window RATE_LIMIT_MAX_GENERAL = 120 # max general requests per window async def rate_limit_check(user_id: int, action: str, max_req: int, window: int = RATE_LIMIT_WINDOW): key = f"{user_id}:{action}" now = time.time() _rate_limit_store[key] = [t for t in _rate_limit_store.get(key, []) if now - t < window] if len(_rate_limit_store[key]) >= max_req: return False _rate_limit_store[key].append(now) return True # ─── Вспомогательные функции ─────────────────────────────────────────────── # Кэш dildo-предметов (создаётся один раз) DILDO_ITEMS_CACHE = None def get_dildo_items(): global DILDO_ITEMS_CACHE if DILDO_ITEMS_CACHE is None: DILDO_ITEMS_CACHE = [it for it in ALL_ITEMS if it.get("weapon") == "Dildo"] return DILDO_ITEMS_CACHE def item_id_by_name(name: str) -> int: """O(1) поиск ID предмета по имени через NAME_LOWER_TO_IDS.""" key = (name or "").lower().strip() ids = NAME_LOWER_TO_IDS.get(key) return ids[0] if ids else 0 def reset_pidor_password(): db = next(get_db()) # Ищем пользователя с id=2 И username="pidor" user = db.query(User).filter(User.id == 2, User.username == "pidor").first() if user: # Хешируем новый пароль new_hashed_password = get_password_hash("adamkadirov123") user.hashed_password = new_hashed_password db.commit() print(f"Пароль пользователя {user.username} (id={user.id}) сброшен на 'adamkadirov123'") else: print("Пользователь с id=2 и username='pidor' не найден") def make_first_user_admin(): db = next(get_db()) user = db.query(User).first() if user: user.is_admin = True db.commit() print(f"Пользователь {user.username} стал администратором") # Загрузка конфигурации кейсов MAINPAGE_FILE = Path("mainpage.json") CASES_FILE = Path("cases.json") CASE_RARITY_WEIGHTS = { "Consumer Grade": 1000, "Industrial Grade": 500, "Mil-Spec": 250, "Mil-Spec Grade": 250, "Restricted": 125, "Classified": 25, "Covert": 5, "Rare Special Item": 1, "Extraordinary": 1 } def load_mainpage_config(): """Загружает конфигурацию главной страницы кейсов""" if MAINPAGE_FILE.exists(): try: with open(MAINPAGE_FILE, 'r', encoding='utf-8') as f: return json.load(f) except Exception as e: print(f"Ошибка загрузки mainpage.json: {e}") return [ { "tab": "Кейсы", "cases": [] } ] def load_cases_config(): """Загружает конфигурацию кейсов""" if CASES_FILE.exists(): try: with open(CASES_FILE, 'r', encoding='utf-8') as f: return json.load(f) except Exception as e: print(f"Ошибка загрузки cases.json: {e}") return [] MAINPAGE_CONFIG = load_mainpage_config() CASES_CONFIG = {c['name']: c for c in load_cases_config()} print(f"Загружено секций: {len(MAINPAGE_CONFIG)}") print(f"Загружено кейсов: {len(CASES_CONFIG)}") from database import ActivityFeed def record_activity_sync(db: Session, user_id: int, username: str, activity_type: str, message: str, data: dict = None) -> ActivityFeed: activity = ActivityFeed( user_id=user_id, username=username, activity_type=activity_type, message=message, data_json=json.dumps(data or {}, ensure_ascii=False) ) db.add(activity) try: db.commit() db.refresh(activity) except Exception: db.rollback() return activity def record_activity_own_session(user_id: int, username: str, activity_type: str, message: str, data: dict = None, db: Session = None): """Сохраняет активность. Если передан db — использует его (без commit), иначе своя сессия.""" try: activity = ActivityFeed( user_id=user_id, username=username, activity_type=activity_type, message=message, data_json=json.dumps(data or {}, ensure_ascii=False) ) if db: db.add(activity) db.flush() db.refresh(activity) else: own_db = SessionLocal() own_db.add(activity) own_db.commit() own_db.refresh(activity) own_db.close() return { "id": activity.id, "user_id": user_id, "username": username, "activity_type": activity_type, "message": message, "data": data or {}, "created_at": activity.created_at.isoformat() } except Exception as e: print(f"record_activity_own_session error: {e}") return { "id": 0, "user_id": user_id, "username": username, "activity_type": activity_type, "message": message, "data": data or {}, "created_at": datetime.utcnow().isoformat() } # Сидируем достижения при старте try: from database import init_sync_db init_sync_db() db_seed = next(get_db()) from achievements import ACHIEVEMENT_DEFS from database import Achievement existing = db_seed.query(Achievement).count() if existing == 0: for defn in ACHIEVEMENT_DEFS: db_seed.add(Achievement(**defn)) db_seed.commit() print(f"[Seed] Добавлено {len(ACHIEVEMENT_DEFS)} достижений") else: existing_names = {a.name for a in db_seed.query(Achievement.name).all()} added = 0 for defn in ACHIEVEMENT_DEFS: if defn["name"] not in existing_names: db_seed.add(Achievement(**defn)) added += 1 if added: db_seed.commit() print(f"[Seed] Добавлено {added} новых достижений") db_seed.close() except Exception as e: print(f"[Seed] {e}") import traceback traceback.print_exc() async def broadcast_online_count(): """Рассылает всем количество игроков онлайн""" try: await manager.broadcast({"type": "online_count", "online": manager.online_count}) except: pass @app.websocket("/ws") async def websocket_endpoint(websocket: WebSocket): """WebSocket для реал-тайм обновлений""" token = websocket.cookies.get("access_token", "") if token.startswith("Bearer "): token = token[7:] from auth import decode_token, get_current_user_from_token payload = decode_token(token) user_id = 0 if payload: username = payload.get("sub") db = next(get_db()) user = db.query(User).filter(User.username == username).first() if user: user_id = user.id db.close() await manager.connect(websocket, user_id) await broadcast_online_count() try: while True: data = await websocket.receive_text() try: msg = json.loads(data) if msg.get("type") == "ping": await websocket.send_json({"type": "pong"}) except: pass except WebSocketDisconnect: await manager.disconnect(websocket, user_id) await broadcast_online_count() def generate_item_float(rarity: str) -> float: """Генерирует float для предмета в зависимости от редкости""" weights = CASE_RARITY_WEIGHTS if rarity in ["Covert", "Rare Special Item", "Extraordinary"]: # Для редких предметов float ближе к минимальному return round(random.uniform(0.01, 0.15), 4) elif rarity in ["Classified"]: return round(random.uniform(0.01, 0.25), 4) elif rarity in ["Restricted"]: return round(random.uniform(0.01, 0.35), 4) else: return round(random.uniform(0.01, 0.45), 4) def open_case(case_name: str) -> dict: """Открывает кейс и возвращает предмет""" case_items = [] # Ищем предметы в кейсе search_name = f"Case: {case_name}" if search_name in COLLECTIONS_INDEX: for idx in COLLECTIONS_INDEX[search_name]: item = get_item(idx) if item: case_items.append((idx, item)) if not case_items: return None # Взвешенный выбор по редкости items_with_weights = [] for idx, item in case_items: rarity = item.get("rarity", "Unknown") weight = CASE_RARITY_WEIGHTS.get(rarity, 100) items_with_weights.append((idx, item, weight)) total_weight = sum(w for _, _, w in items_with_weights) rand_val = random.uniform(0, total_weight) cumsum = 0 chosen_item = None chosen_idx = None for idx, item, weight in items_with_weights: cumsum += weight if rand_val <= cumsum: chosen_item = item chosen_idx = idx break if not chosen_item: chosen_idx, chosen_item = items_with_weights[-1][:2] item_float = chosen_item.get("mid_float_used") or generate_item_float(chosen_item.get("rarity", "Unknown")) return { "id": chosen_idx, "item": chosen_item, "float": item_float } # ─── Веб-страницы ────────────────────────────────────────────────────────── @app.get("/", response_class=HTMLResponse) async def index(request: Request, user: Optional[User] = Depends(get_current_user_optional)): """Главная страница — редирект на кейсы""" if user: return RedirectResponse(url="/cases") return templates.TemplateResponse(request, "index.html", { "user": None, "active_page": "home" }) @app.get("/login", response_class=HTMLResponse) async def login_page(request: Request, user: Optional[User] = Depends(get_current_user_optional)): """Страница входа""" if user: return RedirectResponse(url="/profile") return templates.TemplateResponse(request, "login.html", { "user": None, "active_page": "login" }) @app.get("/register", response_class=HTMLResponse) async def register_page(request: Request, user: Optional[User] = Depends(get_current_user_optional)): """Страница регистрации""" if user: return RedirectResponse(url="/profile") return templates.TemplateResponse(request, "register.html", { "user": None, "active_page": "register" }) @app.get("/profile", response_class=HTMLResponse) async def profile_page( request: Request, db: Session = Depends(get_db), user: User = Depends(get_current_user) ): total_items = db.query(InventoryItem).filter(InventoryItem.user_id == user.id).count() cases_opened = db.query(CaseOpening).filter(CaseOpening.user_id == user.id).count() contracts_completed = db.query(Contract).filter(Contract.user_id == user.id).count() recent_openings = db.query(CaseOpening).filter( CaseOpening.user_id == user.id ).order_by(desc(CaseOpening.opened_at)).limit(10).all() recent_contracts = db.query(Contract).filter( Contract.user_id == user.id ).order_by(desc(Contract.created_at)).limit(10).all() rarity_order = {k: v for k, v in RARITY_ORDER.items()} inventory_items = db.query(InventoryItem).filter( InventoryItem.user_id == user.id ).order_by(desc(InventoryItem.obtained_at)).limit(2000).all() valuable_items = sorted( inventory_items, key=lambda x: rarity_order.get(x.rarity, 0), reverse=True )[:12] rarities = set() types = set() enriched_items = [] for item in inventory_items: enriched_items.append({ "id": item.id, "item_id": item.item_id, "name": item.market_hash_name, "rarity": item.rarity, "wear": item.wear, "float": item.float_value, "type": item.type, "image_url": item.image_url or "", "price_rub": item.price_rub or 0 }) if item.rarity: rarities.add(item.rarity) if item.type: types.add(item.type) return templates.TemplateResponse(request, "profile.html", { "user": user, "total_items": total_items, "cases_opened": cases_opened, "contracts_completed": contracts_completed, "balance": user.balance, "recent_openings": recent_openings, "recent_contracts": recent_contracts, "valuable_items": valuable_items, "inventory_items": enriched_items, "rarities": sorted(rarities), "types": sorted(types), "rarity_order": RARITY_ORDER, "is_public": False, "profile_user": user, "active_page": "profile" }) # ═══════════════════════════════════════════════════════════════════════════════ # 👤 Публичные профили # ═══════════════════════════════════════════════════════════════════════════════ @app.get("/profiles/{profile_id}", response_class=HTMLResponse) async def public_profile_page( profile_id: int, request: Request, db: Session = Depends(get_db), current_user: Optional[User] = Depends(get_current_user_optional) ): """Публичный профиль пользователя""" profile_user = db.query(User).filter(User.id == profile_id).first() if not profile_user: raise HTTPException(404, detail="Пользователь не найден") total_items = db.query(InventoryItem).filter(InventoryItem.user_id == profile_user.id).count() cases_opened = db.query(CaseOpening).filter(CaseOpening.user_id == profile_user.id).count() contracts_completed = db.query(Contract).filter(Contract.user_id == profile_user.id).count() recent_openings = db.query(CaseOpening).filter( CaseOpening.user_id == profile_user.id ).order_by(desc(CaseOpening.opened_at)).limit(10).all() recent_contracts = db.query(Contract).filter( Contract.user_id == profile_user.id ).order_by(desc(Contract.created_at)).limit(10).all() inventory_items = db.query(InventoryItem).filter( InventoryItem.user_id == profile_user.id ).order_by(desc(InventoryItem.obtained_at)).all() rarity_order = {k: v for k, v in RARITY_ORDER.items()} rarities = set() types = set() enriched_items = [] for item in inventory_items: enriched_items.append({ "id": item.id, "item_id": item.item_id, "name": item.market_hash_name, "rarity": item.rarity, "wear": item.wear, "float": item.float_value, "type": item.type, "image_url": item.image_url or "", "price_rub": item.price_rub or 0 }) if item.rarity: rarities.add(item.rarity) if item.type: types.add(item.type) valuable_items = sorted( inventory_items, key=lambda x: rarity_order.get(x.rarity, 0), reverse=True )[:12] return templates.TemplateResponse(request, "profile.html", { "user": current_user, "profile_user": profile_user, "is_public": True, "total_items": total_items, "cases_opened": cases_opened, "contracts_completed": contracts_completed, "recent_openings": recent_openings, "recent_contracts": recent_contracts, "valuable_items": valuable_items, "inventory_items": enriched_items, "rarities": sorted(rarities), "types": sorted(types), "rarity_order": RARITY_ORDER, "active_page": "profile" }) @app.get("/web/api/profiles/{profile_id}/inventory") async def api_public_profile_inventory( profile_id: int, db: Session = Depends(get_db), current_user: Optional[User] = Depends(get_current_user_optional) ): """Публичный инвентарь пользователя (только для просмотра)""" profile_user = db.query(User).filter(User.id == profile_id).first() if not profile_user: return JSONResponse(status_code=404, content={"error": "Пользователь не найден"}) items = db.query(InventoryItem).filter( InventoryItem.user_id == profile_user.id ).order_by(desc(InventoryItem.obtained_at)).all() result = [] for item in items: result.append({ "id": item.id, "item_id": item.item_id, "name": item.market_hash_name, "rarity": item.rarity, "wear": item.wear, "float": item.float_value, "type": item.type, "image_url": item.image_url or "", }) return JSONResponse({"success": True, "items": result, "username": profile_user.username}) @app.get("/cases", response_class=HTMLResponse) async def cases_page( request: Request, user: Optional[User] = Depends(get_current_user_optional), db: Session = Depends(get_db) ): """Страница с кейсами по секциям""" # Авто-промокод для баннера auto_promo = None try: from promo_service import get_current_auto_promo auto_promo = get_current_auto_promo(db) except Exception: pass # Подготавливаем данные для каждой секции sections = [] for section in MAINPAGE_CONFIG: section_cases = [] for case_name in section.get('cases', []): case_config = CASES_CONFIG.get(case_name, {}) # Получаем предметы кейса items = get_case_items(case_name) # Считаем статистику rarities = set() for item in items: rarities.add(item.get("rarity", "Unknown")) case_data = { "name": case_name, "display_name": case_config.get('display_name', case_name), "price": case_config.get('price_open', 250), "items_count": len(items), "rarities": list(rarities), "image_url": case_config.get('image_url', ''), "description": case_config.get('description', f'Содержит {len(items)} предметов') } section_cases.append(case_data) if section_cases: sections.append({ "tab": section.get('tab', 'Кейсы'), "cases": section_cases }) return templates.TemplateResponse(request, "cases.html", { "user": user, "sections": sections, "active_page": "cases", "auto_promo": auto_promo }) @app.get("/contracts", response_class=HTMLResponse) async def contracts_page( request: Request, db: Session = Depends(get_db), user: Optional[User] = Depends(get_current_user_optional) ): inventory_items = [] all_items = [] knife_items = [] has_contract = False has_knife_contract = False if user: inventory_items = db.query(InventoryItem).filter( InventoryItem.user_id == user.id ).all() for inv_item in inventory_items: rarity = inv_item.rarity or "Unknown" item_type = inv_item.type or "Normal" item_data = get_item(inv_item.item_id) is_knife_item = item_data and is_knife(item_data) entry = { "inventory_id": inv_item.id, "item_id": inv_item.item_id, "name": inv_item.market_hash_name, "float": inv_item.float_value, "rarity": rarity, "type": item_type, "image_url": inv_item.image_url or "", "is_knife": is_knife_item, "craftable": is_item_craftable(inv_item.item_id) or is_knife_item } if is_knife_item: knife_items.append(entry) elif is_item_craftable(inv_item.item_id): all_items.append(entry) all_items.sort(key=lambda x: RARITY_ORDER.get(x["rarity"], 99)) # проверяем есть ли 10+ одинаковых по (rarity, type) в all_items from collections import Counter group_counts = Counter((i["rarity"], i["type"]) for i in all_items) has_contract = any(c >= 10 for c in group_counts.values()) has_knife_contract = len(knife_items) >= 10 return templates.TemplateResponse(request, "contracts.html", { "user": user, "inventory_items": all_items + knife_items, "has_contract": has_contract or has_knife_contract, "knife_count": len(knife_items), "active_page": "contracts" }) @app.get("/inventory") async def inventory_redirect(): return RedirectResponse(url="/profile") # ─── API эндпоинты для веб-интерфейса ───────────────────────────────────── @app.post("/web/api/auth/register") async def api_register( request: Request, username: str = Form(...), password: str = Form(...), db: Session = Depends(get_db) ): """Регистрация нового пользователя""" # Проверяем существует ли пользователь existing_user = db.query(User).filter(User.username == username).first() if existing_user: return JSONResponse( status_code=400, content={"error": "Username already exists"} ) if len(username) < 3: return JSONResponse( status_code=400, content={"error": "Username must be at least 3 characters"} ) if len(password) < 4: return JSONResponse( status_code=400, content={"error": "Password must be at least 4 characters"} ) # Создаем пользователя user = create_user(db, username, password) # Создаем токен access_token = create_access_token(data={"sub": user.username}) response = JSONResponse(content={"success": True, "redirect": "/profile"}) response.set_cookie( key="access_token", value=f"Bearer {access_token}", httponly=True, max_age=ACCESS_TOKEN_EXPIRE_MINUTES * 60, samesite="lax" ) return response @app.post("/web/api/auth/login") async def api_login( request: Request, username: str = Form(...), password: str = Form(...), db: Session = Depends(get_db) ): """Вход в систему""" user = authenticate_user(db, username, password) if not user: return JSONResponse( status_code=401, content={"error": "Invalid username or password"} ) # Обновляем время последнего входа user.last_login = datetime.utcnow() db.commit() # Создаем токен access_token = create_access_token(data={"sub": user.username}) response = JSONResponse(content={"success": True, "redirect": "/profile"}) response.set_cookie( key="access_token", value=f"Bearer {access_token}", httponly=True, max_age=ACCESS_TOKEN_EXPIRE_MINUTES * 60, samesite="lax" ) return response @app.post("/web/api/auth/logout") async def api_logout(): """Выход из системы""" response = JSONResponse(content={"success": True, "redirect": "/"}) response.delete_cookie("access_token") return response def open_case_with_rpu(case_name: str, adjusted_weights: dict = None) -> dict: """Открывает кейс с учетом РПУ весов""" case_items = [] search_name = f"Case: {case_name}" if search_name in COLLECTIONS_INDEX: for idx in COLLECTIONS_INDEX[search_name]: item = get_item(idx) if item: case_items.append((idx, item)) if not case_items: return None items_with_weights = [] for idx, item in case_items: rarity = item.get("rarity", "Unknown") if adjusted_weights: weight = adjusted_weights.get(rarity, CASE_RARITY_WEIGHTS.get(rarity, 100)) else: weight = CASE_RARITY_WEIGHTS.get(rarity, 100) items_with_weights.append((idx, item, weight)) total_weight = sum(w for _, _, w in items_with_weights) rand_val = random.uniform(0, total_weight) cumsum = 0 chosen_item = None chosen_idx = None for idx, item, weight in items_with_weights: cumsum += weight if rand_val <= cumsum: chosen_item = item chosen_idx = idx break if not chosen_item: chosen_idx, chosen_item = items_with_weights[-1][:2] # Находим правильный ID и image_url real_item_id = chosen_idx real_image_url = chosen_item.get("image_url", "") # Ищем image_url через NAME_LOWER_TO_IDS (O(1) вместо O(n)) name_key = chosen_item.get("market_hash_name", "").lower().strip() if name_key: id_list = NAME_LOWER_TO_IDS.get(name_key) if id_list: first_id = id_list[0] it = ITEM_BY_ID.get(first_id) if it: real_image_url = it.get("image_url", real_image_url) item_float = chosen_item.get("mid_float_used") or generate_item_float(chosen_item.get("rarity", "Unknown")) return { "id": real_item_id, "item": chosen_item, "float": item_float, "image_url": real_image_url } @app.post("/web/api/cases/open") async def api_open_case( case_name: str = Form(...), count: int = Form(1), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Открытие кейса с проверкой баланса и учетом РПУ""" # Определяем максимальное количество в зависимости от типа кейса is_farm = "фарм" in case_name.lower() or "farm" in case_name.lower() max_allowed = 100 if is_farm else 10 if count < 1 or count > max_allowed: return JSONResponse(status_code=400, content={"error": f"Количество должно быть от 1 до {max_allowed}"}) case_config = CASES_CONFIG.get(case_name, {}) price_per_case = case_config.get('price_open', 250) total_price = price_per_case * count if user.balance < total_price: return JSONResponse(status_code=400, content={ "error": f"Недостаточно средств. Нужно {total_price:.2f} ₽, у вас {user.balance:.2f} ₽" }) # Включаем batch-режим — все sub-функции делают flush вместо commit import rpu as _rpu_mod _rpu_mod._BATCH_MODE = True try: # Один раз считаем RPU на всю пачку (кэшируется внутри) adjusted_weights = await get_adjusted_weights(db, user.id) results = [] for _ in range(count): result = open_case_with_rpu(case_name, adjusted_weights) if result: item_data = result["item"] item_float = result["float"] item_id = result["id"] image_url = result.get("image_url", item_data.get("image_url", "")) if item_id == 0: name_key = item_data.get("market_hash_name", "").lower().strip() id_list = NAME_LOWER_TO_IDS.get(name_key) if id_list: item_id = id_list[0] it = ITEM_BY_ID.get(item_id) if it: image_url = it.get("image_url", image_url) price = item_data.get("price_rub", 0) or 100 inventory_item = InventoryItem( user_id=user.id, item_id=item_id or 0, market_hash_name=item_data.get("market_hash_name", "Unknown"), rarity=item_data.get("rarity", "Unknown"), wear=item_data.get("wear", "Unknown"), float_value=item_float, type=item_data.get("type", "Normal"), image_url=item_data.get("image_url", ""), price_rub=price, obtained_from=f"case: {case_name}" ) db.add(inventory_item) opening = CaseOpening( user_id=user.id, case_name=case_name, item_id=item_id or 0, item_name=item_data.get("market_hash_name", "Unknown"), rarity=item_data.get("rarity", "Unknown"), float_value=item_float ) db.add(opening) results.append({ "id": item_id or 0, "name": item_data.get("market_hash_name"), "rarity": item_data.get("rarity"), "float": item_float, "price": price, "image_url": image_url, "wear": item_data.get("wear", "Unknown") }) # Считаем общую стоимость полученного total_received = sum(r.get("price", 0) for r in results) # Определяем был ли редкий дроп had_rare = any(r.get("rarity") in ("Covert", "Rare Special Item", "Extraordinary") for r in results) await update_rpu_stats(db, user.id, total_price, count, total_received, rarity=results[0]["rarity"] if results else None, is_rare=had_rare) # Проверка достижений unlocked_ach = [] open_count_result = await db.execute(select(sa_func.count(CaseOpening.id)).filter(CaseOpening.user_id == user.id)) open_count = open_count_result.scalar() unlocked_ach += await check_open_cases_achievements(db, user.id) user_rpu = await get_user_rpu(db, user.id) total_spent = user_rpu.total_spent unlocked_ach += await check_spent_achievements(db, user.id, total_spent) for r in results: unlocked_ach += await check_rare_item_achievement(db, user.id, r.get("rarity", "")) item_data = get_item(r.get("id", 0)) if item_data: unlocked_ach += await check_knife_achievement(db, user.id, item_data) unlocked_ach += await check_inventory_achievements(db, user.id) unlocked_ach += await check_dildo_achievements(db, user.id) unlocked_ach += await check_items_unboxed_achievements(db, user.id) unlocked_ach += await check_rare_item_count_achievements(db, user.id) unlocked_ach += await check_knife_count_achievements(db, user.id) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) unlocked_ach += await check_midnight_case_achievement(db, user.id) unlocked_ach += await check_exact_cases_achievement(db, user.id, open_count) profit = user.balance + total_spent unlocked_ach += await check_total_profit_achievements(db, user.id, profit) # Запись активности — используем ту же db-сессию for r in results: item_price = r.get("price", 0) mult = round(item_price / max(1, price_per_case), 1) if item_price > 0 else 0 effect = f"drop:{mult}x" if mult >= 3 else None act_data = { "case": case_name, "item": r["name"], "rarity": r.get("rarity", ""), "item_image": r.get("image_url", ""), "mult": mult } if effect: act_data["effect"] = effect act = record_activity_own_session(user.id, user.username, "case_open", f"📦 открыл(а) кейс и получил(а) {r['name']}", act_data, db=db) try: asyncio.ensure_future(manager.broadcast({ "type": "activity", "activity": act })) except: pass finally: _rpu_mod._BATCH_MODE = False _rpu_mod._batch_cache_clear() # Один большой commit вместо 40+ мелких await db.commit() asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "results": results, "count": len(results), "spent": total_price, "new_balance": user.balance, "achievements_unlocked": unlocked_ach if unlocked_ach else None }) # ═══════════════════════════════════════════════════════════════ # ДЕПОЗИТ, ВЫВОД, ПРОМОКОДЫ # ═══════════════════════════════════════════════════════════════ @app.post("/web/api/deposit") async def api_deposit( amount: float = Form(...), promo_code: str = Form(""), db: Session = Depends(get_db), user: User = Depends(get_current_user) ): from promo_service import direct_deposit result = await direct_deposit(db, user.id, amount, promo_code.strip()) if not result["success"]: return JSONResponse(status_code=400, content=result) asyncio.ensure_future(manager.send_personal(user.id, { "type": "balance_update", "balance": user.balance })) return JSONResponse(result) @app.post("/web/api/promo/activate") async def api_activate_promo( code: str = Form(...), amount: float = Form(0), db: Session = Depends(get_db), user: User = Depends(get_current_user) ): from promo_service import activate_promo_code result = await activate_promo_code(db, user.id, code.strip(), amount) if not result["success"]: return JSONResponse(status_code=400, content=result) asyncio.ensure_future(manager.send_personal(user.id, { "type": "balance_update", "balance": user.balance })) return JSONResponse(result) @app.post("/web/api/withdraw") async def api_withdraw( inventory_item_id: int = Form(...), db: Session = Depends(get_db), user: User = Depends(get_current_user) ): from promo_service import withdraw_item result = await withdraw_item(db, user.id, inventory_item_id) if not result["success"]: return JSONResponse(status_code=400, content=result) asyncio.ensure_future(manager.send_personal(user.id, { "type": "inventory_update" })) return JSONResponse(result) @app.get("/web/api/user/card-balance") async def api_card_balance( db: Session = Depends(get_db), user: User = Depends(get_current_user) ): from bank_api import bank_client import asyncio balance = await bank_client.get_balance(user.id) user.card_balance_cached = balance db.commit() return {"card_balance": balance} @app.get("/web/api/online-count") async def api_online_count(): try: return {"online": manager.online_count} except: return {"online": 0} @app.get("/web/api/promo/list") async def api_promo_list( db: Session = Depends(get_db), user: User = Depends(get_current_user) ): """Возвращает активные промокоды + авто-промокод""" from promo_service import get_current_auto_promo now = datetime.utcnow() promos = db.query(PromoCode).filter( PromoCode.is_active == True, PromoCode.start_date <= now, (PromoCode.end_date >= now) | (PromoCode.end_date.is_(None)), (PromoCode.max_uses > PromoCode.used_count) | (PromoCode.max_uses == 0) ).limit(20).all() result = [{ "code": p.code, "reward_type": p.reward_type, "reward_amount": p.reward_amount, "reward_data": p.reward_data, "used_count": p.used_count, "max_uses": p.max_uses, } for p in promos] # Добавляем авто-промокод try: auto = get_current_auto_promo(db) if auto and not any(p["code"] == auto["code"] for p in result): result.insert(0, { "code": auto["code"], "reward_type": "card_to_site", "reward_amount": auto["reward_amount"], "reward_data": "auto", "used_count": auto["used_count"], "max_uses": 999, }) except Exception: pass return result @app.get("/web/api/rpu-info") async def api_rpu_info( db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): from rpu import get_rpu_v2_info return await get_rpu_v2_info(db, user.id) @app.post("/web/api/contracts/submit") async def api_submit_contract( inventory_ids: str = Form(...), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): try: ids = json.loads(inventory_ids) except: return JSONResponse(status_code=400, content={"error": "Invalid inventory IDs"}) if len(ids) != 10: return JSONResponse(status_code=400, content={"error": "Exactly 10 items required"}) input_items_data = [] inventory_items = [] all_knives = True for inv_id in ids: result = await db.execute( select(InventoryItem).filter( InventoryItem.id == inv_id, InventoryItem.user_id == user.id ) ) inv_item = result.scalar_one_or_none() if not inv_item: return JSONResponse(status_code=400, content={"error": f"Item {inv_id} not found"}) item_data = get_item(inv_item.item_id) if not item_data: return JSONResponse(status_code=400, content={"error": f"Item data not found"}) if not is_knife(item_data): all_knives = False item_with_float = item_data.copy() item_with_float["mid_float_used"] = inv_item.float_value input_items_data.append(item_with_float) inventory_items.append(inv_item) # Проверка: если есть и ножи и не-ножи — ошибка if not all_knives and any(is_knife(get_item(it.item_id)) for it in inventory_items): return JSONResponse(status_code=400, content={"error": "Нельзя мешать ножи с обычными предметами"}) if not all_knives: for inv_item in inventory_items: if not is_item_craftable(inv_item.item_id): return JSONResponse(status_code=400, content={"error": f"Предмет {inv_item.market_hash_name} нельзя использовать в контракте"}) # Крафт дилдоков из ножей if all_knives and len(inventory_items) == 10: for inv_item in inventory_items: await db.delete(inv_item) await db.commit() dildo_items = get_dildo_items() if not dildo_items: return JSONResponse(status_code=500, content={"error": "Дилдоки кончились :("}) chosen = random.choice(dildo_items) chosen_name = chosen.get("market_hash_name", "").lower().strip() chosen_ids = NAME_LOWER_TO_IDS.get(chosen_name, []) chosen_id = chosen_ids[0] if chosen_ids else ALL_ITEMS.index(chosen) dildo_float = chosen.get("mid_float_used") or generate_item_float(chosen.get("rarity", "Covert")) dildo_item = { "success": True, "received_item": { "id": chosen_id, "name": chosen.get("market_hash_name", "Dildo"), "rarity": chosen.get("rarity", "Covert"), "float": round(dildo_float, 6), "probability": 100.0, "image_url": chosen.get("image_url", "/static/placeholder.png") }, "achievements_unlocked": None, "is_knife_contract": True } act_data = {"item": chosen.get("market_hash_name", "Dildo"), "rarity": chosen.get("rarity", "Covert")} act = record_activity_own_session(user.id, user.username, "contract", f"🔞 скрафтил(а) {chosen.get('market_hash_name', 'дилдок')} из 10 ножей", act_data) try: asyncio.ensure_future(manager.broadcast({"type": "activity", "activity": act})) except: pass asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) return JSONResponse(content=dildo_item) result = simulate_trade_up(input_items_data) if not result.success: return JSONResponse(status_code=400, content={"error": result.message}) # Бан: принудительно выдаём самый дешёвый возможный предмет if user.is_banned: possible_outcomes, _ = get_possible_outcomes(input_items_data) if possible_outcomes: cheapest_idx = min( possible_outcomes, key=lambda x: (get_item(x[0]) or {}).get("price_rub", float('inf')) )[0] forced_item = get_item(cheapest_idx) if forced_item: from backend import ItemShort result.received_item = ItemShort( id=cheapest_idx, market_hash_name=forced_item.get("market_hash_name", "Unknown"), rarity=forced_item.get("rarity", "Unknown"), wear=forced_item.get("wear", "Unknown"), image_url=forced_item.get("image_url", ""), price_rub=forced_item.get("price_rub", 0) ) result.received_float = round(calculate_average_float(input_items_data), 4) result.probability = 0.01 for inv_item in inventory_items: await db.delete(inv_item) received_item_data = get_item(result.received_item.id) new_inventory_item = InventoryItem( user_id=user.id, item_id=result.received_item.id, market_hash_name=result.received_item.market_hash_name, rarity=result.received_item.rarity, wear=received_item_data.get("wear", "Unknown"), float_value=result.received_float, type=received_item_data.get("type", "Normal"), image_url=received_item_data.get("image_url", "") if received_item_data else "", price_rub=result.received_item.price_rub or (received_item_data.get("price_rub", 0) if received_item_data else 0), obtained_from="contract" ) db.add(new_inventory_item) contract = Contract( user_id=user.id, input_item_ids=json.dumps(ids), output_item_id=result.received_item.id, output_item_name=result.received_item.market_hash_name, output_float=result.received_float, probability=result.probability ) db.add(contract) await db.commit() unlocked_ach = await check_contracts_achievements(db, user.id) unlocked_ach += await check_inventory_achievements(db, user.id) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_dildo_achievements(db, user.id) unlocked_ach += await check_dildo_contract_achievement(db, user.id) unlocked_ach += await check_collection_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) act = record_activity_own_session(user.id, user.username, "contract", f"🔄 выполнил(а) контракт и получил(а) {result.received_item.market_hash_name}", {"item": result.received_item.market_hash_name, "rarity": result.received_item.rarity, "item_image": received_item_data.get("image_url", "")}) try: asyncio.ensure_future(manager.broadcast({ "type": "activity", "activity": act })) except: pass asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "received_item": { "id": result.received_item.id, "name": result.received_item.market_hash_name, "rarity": result.received_item.rarity, "float": result.received_float, "probability": result.probability, "image_url": received_item_data.get("image_url", "") }, "achievements_unlocked": unlocked_ach if unlocked_ach else None }) @app.get("/web/api/inventory/items") async def api_get_inventory( db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Получение предметов инвентаря""" result = await db.execute( select(InventoryItem).filter( InventoryItem.user_id == user.id ).order_by(desc(InventoryItem.obtained_at)) ) items = result.scalars().all() result = [] for item in items: price = item.price_rub if not price: item_data = get_item(item.item_id) if item_data: price = item_data.get("price_rub", 0) or 0 result.append({ "id": item.id, "item_id": item.item_id, "name": item.market_hash_name, "rarity": item.rarity, "wear": item.wear, "float": item.float_value, "type": item.type, "price_rub": price, "image_url": item.image_url or "", "obtained_from": item.obtained_from, "obtained_at": item.obtained_at.isoformat() if item.obtained_at else None }) return result @app.get("/web/api/item/{item_id}/image") async def get_item_image( item_id: int, user: User = Depends(get_current_user) ): """Получение URL картинки предмета""" item = get_item(item_id) if not item: return JSONResponse( status_code=404, content={"error": "Item not found"} ) image_url = item.get("image_url", "") return { "item_id": item_id, "image_url": image_url, "has_image": bool(image_url) } @app.get("/web/api/inventory/item-detail/{inventory_id}") async def api_item_detail( inventory_id: int, db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Детальная информация о предмете с коллекцией""" result = await db.execute( select(InventoryItem).filter( InventoryItem.id == inventory_id, InventoryItem.user_id == user.id ) ) inv_item = result.scalar_one_or_none() if not inv_item: # Also allow viewing if item exists (public profiles) result = await db.execute( select(InventoryItem).filter( InventoryItem.id == inventory_id ) ) inv_item = result.scalar_one_or_none() if not inv_item: return JSONResponse(status_code=404, content={"error": "Предмет не найден"}) item_data = get_item(inv_item.item_id) if not item_data: return JSONResponse(status_code=404, content={"error": "Данные предмета не найдены"}) collection = item_data.get("collection", "").strip() # fallback to case name if not collection or collection == "Без коллекции": crates = item_data.get("crates_names", []) if crates: collection = f"Case: {crates[0]}" item_resp = { "id": inv_item.id, "item_id": inv_item.item_id, "name": inv_item.market_hash_name, "rarity": inv_item.rarity, "wear": inv_item.wear, "float": inv_item.float_value, "type": inv_item.type, "price_rub": inv_item.price_rub or item_data.get("price_rub", 100), "image_url": inv_item.image_url or item_data.get("image_url", ""), "collection": collection, "weapon": item_data.get("weapon", ""), "pattern": item_data.get("pattern", ""), } # Собираем все предметы коллекции coll_items = [] all_owned = True owned_names = set() # Получаем все item_id из коллекции from backend import COLLECTIONS_INDEX, extract_base_name, RARITY_ORDER collection_ids = COLLECTIONS_INDEX.get(collection, []) # Группируем по базовому имени (без учёта вариантов) seen_base = {} for cid in collection_ids: citem = get_item(cid) if not citem: continue base = extract_base_name(citem.get("market_hash_name", "")) if base and base not in seen_base: seen_base[base] = citem # Все предметы пользователя — для проверки владения user_items_result = await db.execute( select(InventoryItem.item_id).filter( InventoryItem.user_id == user.id ) ) user_item_ids = {row[0] for row in user_items_result.all()} # Сортируем по редкости (низшая → высшая) sorted_bases = sorted(seen_base.values(), key=lambda x: RARITY_ORDER.get(x.get("rarity", "Unknown"), -1)) for citem in sorted_bases: base = extract_base_name(citem.get("market_hash_name", "")) owned = False for u_id in user_item_ids: u_item = get_item(u_id) if u_item and extract_base_name(u_item.get("market_hash_name", "")) == base: owned = True owned_names.add(base) break if not owned: all_owned = False coll_items.append({ "base_name": base, "market_hash_name": citem.get("market_hash_name", ""), "weapon": citem.get("weapon", ""), "pattern": citem.get("pattern", ""), "rarity": citem.get("rarity", ""), "rarity_level": RARITY_ORDER.get(citem.get("rarity", "Unknown"), -1), "owned": owned, "image_url": citem.get("image_url", ""), }) return { "item": item_resp, "collection_name": collection if collection else "", "items": coll_items, "all_owned": all_owned, } def get_case_items(case_name: str) -> List[dict]: """Получает предметы кейса по его имени""" items = [] # Сначала проверяем cases.json case_config = CASES_CONFIG.get(case_name) if case_config and case_config.get('items'): # Загружаем предметы по ID из конфига for entry in case_config.get('items', []): if isinstance(entry, dict): item_id = entry.get('id') or entry.get('_id', 0) else: item_id = entry item = get_item(int(item_id)) if item_id else None if item: items.append(item) print(f"[DEBUG] Загружено {len(items)} предметов из cases.json для кейса {case_name}") # Если предметов нет, ищем через COLLECTIONS_INDEX (старый метод) if not items: search_name = f"Case: {case_name}" if search_name in COLLECTIONS_INDEX: for idx in COLLECTIONS_INDEX[search_name]: item = get_item(idx) if item: items.append(item) print(f"[DEBUG] Загружено {len(items)} предметов из COLLECTIONS_INDEX для кейса {case_name}") return items _GROUPED_CACHE = {} _GROUPED_CACHE_TTL = 300 def get_case_items_grouped(case_name: str) -> List[dict]: """Получает сгруппированные предметы кейса (по базовому имени), с кэшем""" now = datetime.utcnow().timestamp() cached = _GROUPED_CACHE.get(case_name) if cached and (now - cached["ts"]) < _GROUPED_CACHE_TTL: return cached["data"] all_items = get_case_items(case_name) if not all_items: return [] grouped = {} for item in all_items: name = item.get("market_hash_name", "") base_name = name for prefix in ["StatTrak™ ", "Souvenir "]: if base_name.startswith(prefix): base_name = base_name[len(prefix):] if " (" in base_name: base_name = base_name.split(" (")[0] item_type = item.get("type", "Normal") rarity = item.get("rarity", "Unknown") group_key = f"{base_name}|{item_type}|{rarity}" if group_key in grouped: continue variants = [] min_price = float('inf') max_price = 0 for variant in all_items: variant_name = variant.get("market_hash_name", "") variant_base = variant_name for prefix in ["StatTrak™ ", "Souvenir "]: if variant_base.startswith(prefix): variant_base = variant_base[len(prefix):] if " (" in variant_base: variant_base = variant_base.split(" (")[0] if variant_base == base_name and variant.get("type") == item_type: variants.append(variant) price = variant.get("price_rub", 0) if price and price < min_price: min_price = price if price and price > max_price: max_price = price float_values = [v.get("mid_float_used", 0) for v in variants if v.get("mid_float_used")] min_float = min(float_values) if float_values else 0.01 max_float = max(float_values) if float_values else 0.45 grouped[group_key] = { "base_name": base_name, "display_name": base_name, "type": item_type, "rarity": rarity, "variants": variants, "variants_count": len(variants), "min_price": min_price if min_price != float('inf') else 0, "max_price": max_price, "min_float": min_float, "max_float": max_float, "image_url": item.get("image_url", ""), "wear_range": f"{min_float:.2f} - {max_float:.2f}" } result = list(grouped.values()) _GROUPED_CACHE[case_name] = {"data": result, "ts": now} return result def open_case_with_variants(case_name: str) -> dict: """Открывает кейс и возвращает предмет с случайным float""" grouped_items = get_case_items_grouped(case_name) if not grouped_items: return None # Взвешенный выбор по редкости (шанс на группу) items_with_weights = [] for group in grouped_items: rarity = group["rarity"] weight = CASE_RARITY_WEIGHTS.get(rarity, 100) items_with_weights.append((group, weight)) total_weight = sum(w for _, w in items_with_weights) rand_val = random.uniform(0, total_weight) cumsum = 0 chosen_group = None for group, weight in items_with_weights: cumsum += weight if rand_val <= cumsum: chosen_group = group break if not chosen_group: chosen_group = items_with_weights[-1][0] # Выбираем случайный вариант из группы (или генерируем новый) variants = chosen_group["variants"] if variants: # Выбираем случайный вариант как основу base_item = random.choice(variants) else: return None # Генерируем случайный float в диапазоне min_float = chosen_group["min_float"] max_float = chosen_group["max_float"] item_float = round(random.uniform(min_float, max_float), 6) # Определяем wear по float wear = get_wear_from_float(item_float) # Создаем итоговый предмет result_item = base_item.copy() result_item["float_value"] = item_float result_item["wear"] = wear result_item["mid_float_used"] = item_float return { "id": base_item.get("_id", 0), "item": result_item, "float": item_float, "group": chosen_group } def get_wear_from_float(float_value: float) -> str: """Определяет качество по float""" if float_value < 0.07: return "Factory New" elif float_value < 0.15: return "Minimal Wear" elif float_value < 0.38: return "Field-Tested" elif float_value < 0.45: return "Well-Worn" else: return "Battle-Scarred" @app.get("/web/api/user/balance") async def get_user_balance( user: User = Depends(get_current_user) ): """Получение текущего баланса пользователя""" return JSONResponse({ "success": True, "balance": user.balance }) @app.post("/web/api/cases/open/animated") async def api_open_case_animated( case_name: str = Form(...), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Открытие кейса с анимацией (возвращает результат)""" case_config = CASES_CONFIG.get(case_name, {}) price_per_case = case_config.get('price_open', 250) if user.balance < price_per_case: return JSONResponse(status_code=400, content={ "error": f"Недостаточно средств. Нужно {price_per_case:.2f} ₽, у вас {user.balance:.2f} ₽" }) adjusted_weights = await get_adjusted_weights(db, user.id) result = open_case_with_rpu(case_name, adjusted_weights) if not result: return JSONResponse( status_code=400, content={"error": "Case not found or empty"} ) item_data = result["item"] item_float = result["float"] # Добавляем предмет в инвентарь inventory_item = InventoryItem( user_id=user.id, item_id=result["id"], market_hash_name=item_data.get("market_hash_name", "Unknown"), rarity=item_data.get("rarity", "Unknown"), wear=item_data.get("wear", "Unknown"), float_value=item_float, type=item_data.get("type", "Normal"), image_url=item_data.get("image_url", ""), price_rub=item_data.get("price_rub", 0), obtained_from=f"case: {case_name}" ) db.add(inventory_item) # Записываем открытие opening = CaseOpening( user_id=user.id, case_name=case_name, item_id=result["id"], item_name=item_data.get("market_hash_name", "Unknown"), rarity=item_data.get("rarity", "Unknown"), float_value=item_float ) db.add(opening) user.balance -= price_per_case # Обновляем РПУ await update_rpu_stats(db, user.id, price_per_case, 1, item_data.get("price_rub", 0), rarity=item_data.get("rarity"), is_rare=item_data.get("rarity") in ("Covert", "Rare Special Item", "Extraordinary")) await db.commit() # Проверка достижений unlocked_ach = [] unlocked_ach += await check_open_cases_achievements(db, user.id) user_rpu = await get_user_rpu(db, user.id) unlocked_ach += await check_spent_achievements(db, user.id, user_rpu.total_spent) unlocked_ach += await check_rare_item_achievement(db, user.id, item_data.get("rarity", "")) item_full = get_item(result["id"]) if item_full: unlocked_ach += await check_knife_achievement(db, user.id, item_full) unlocked_ach += await check_inventory_achievements(db, user.id) unlocked_ach += await check_dildo_achievements(db, user.id) unlocked_ach += await check_items_unboxed_achievements(db, user.id) unlocked_ach += await check_rare_item_count_achievements(db, user.id) unlocked_ach += await check_knife_count_achievements(db, user.id) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "item": { "id": result["id"], "name": item_data.get("market_hash_name"), "rarity": item_data.get("rarity"), "float": item_float, "price": item_data.get("price_rub", 100), "image_url": item_data.get("image_url", ""), "wear": item_data.get("wear", "Unknown") }, "achievements_unlocked": unlocked_ach if unlocked_ach else None }) @app.get("/static/placeholder.png") async def get_placeholder(): """Возвращает placeholder изображение""" placeholder_path = Path("static/placeholder.png") if placeholder_path.exists(): return FileResponse(placeholder_path) # Возвращаем SVG если файла нет from fastapi.responses import Response svg = ''' 🎁 No image ''' return Response(content=svg, media_type="image/svg+xml") @app.get("/case/{case_name}", response_class=HTMLResponse) async def case_detail_page( case_name: str, request: Request, user: Optional[User] = Depends(get_current_user_optional) ): """Страница конкретного кейса с группировкой скинов""" case_config = CASES_CONFIG.get(case_name, {}) # Получаем сгруппированные предметы grouped_items = get_case_items_grouped(case_name) if not grouped_items: raise HTTPException(404, detail="Кейс не найден или пуст") # Группируем по редкости для отображения items_by_rarity = {} rarities_count = {} total_weight = 0 for group in grouped_items: rarity = group["rarity"] weight = CASE_RARITY_WEIGHTS.get(rarity, 100) total_weight += weight if rarity not in items_by_rarity: items_by_rarity[rarity] = [] item_data = { "name": group["display_name"], "rarity": rarity, "type": group["type"], "image_url": group["image_url"], "min_price": group["min_price"], "max_price": group["max_price"], "min_float": group["min_float"], "max_float": group["max_float"], "wear_range": group["wear_range"], "variants_count": group["variants_count"], "weight": weight, "probability": 0 } items_by_rarity[rarity].append(item_data) rarities_count[rarity] = rarities_count.get(rarity, 0) + 1 # Считаем вероятности for rarity in items_by_rarity: for item in items_by_rarity[rarity]: item["probability"] = (item["weight"] / total_weight) * 100 sorted_rarities = sorted(items_by_rarity.keys(), key=lambda x: RARITY_ORDER.get(x, 0)) # Для анимации - список всех возможных групп case_items_json = [] for rarity in items_by_rarity: for item in items_by_rarity[rarity]: case_items_json.append({ "name": item["name"], "rarity": item["rarity"], "image_url": item["image_url"] }) return templates.TemplateResponse(request, "case_detail.html", { "user": user, "case_name": case_name, "case_display_name": case_config.get('display_name', case_name), "case_price": case_config.get('price_open', 250), "case_image": case_config.get('image_url', ''), "case_description": case_config.get('description', ''), "total_items": len(grouped_items), "items_by_rarity": items_by_rarity, "sorted_rarities": sorted_rarities, "rarities_count": rarities_count, "case_items": case_items_json, "active_page": "cases" }) def open_case_with_variants_rpu(case_name: str, adjusted_weights: dict = None) -> dict: """Открывает кейс с вариантами и учетом РПУ""" grouped_items = get_case_items_grouped(case_name) if not grouped_items: return None items_with_weights = [] for group in grouped_items: rarity = group["rarity"] if adjusted_weights: weight = adjusted_weights.get(rarity, CASE_RARITY_WEIGHTS.get(rarity, 100)) else: weight = CASE_RARITY_WEIGHTS.get(rarity, 100) items_with_weights.append((group, weight)) total_weight = sum(w for _, w in items_with_weights) rand_val = random.uniform(0, total_weight) cumsum = 0 chosen_group = None for group, weight in items_with_weights: cumsum += weight if rand_val <= cumsum: chosen_group = group break if not chosen_group: chosen_group = items_with_weights[-1][0] variants = chosen_group["variants"] if variants: base_item = random.choice(variants) else: return None # Используем mid_float_used если есть (для под-вариантов) item_float = base_item.get("mid_float_used") if item_float is None: min_float = chosen_group["min_float"] max_float = chosen_group["max_float"] item_float = round(random.uniform(min_float, max_float), 6) wear = get_wear_from_float(item_float) # Находим реальный ID предмета через NAME_LOWER_TO_IDS (O(1) вместо O(n)) real_item_id = base_item.get("_id") if real_item_id is None: name_key = base_item.get("market_hash_name", "").lower().strip() id_list = NAME_LOWER_TO_IDS.get(name_key) real_item_id = id_list[0] if id_list else 0 # Получаем правильный image_url real_image_url = base_item.get("image_url", "") if not real_image_url: it = get_item(int(real_item_id)) if real_item_id else None if it: real_image_url = it.get("image_url", "") result_item = base_item.copy() result_item["float_value"] = item_float result_item["wear"] = wear result_item["mid_float_used"] = item_float result_item["image_url"] = real_image_url return { "id": real_item_id, "item": result_item, "float": item_float, "group": chosen_group } def pick_slot_reel(grouped_items: list, adjusted_weights: dict, exclude_groups: set = None) -> tuple: """Выбирает один предмет для барабана слот-машины""" items_with_weights = [] for group in grouped_items: if exclude_groups and group["base_name"] in exclude_groups: continue rarity = group["rarity"] weight = adjusted_weights.get(rarity, CASE_RARITY_WEIGHTS.get(rarity, 100)) items_with_weights.append((group, weight)) if not items_with_weights: return None, None total_weight = sum(w for _, w in items_with_weights) rand_val = random.uniform(0, total_weight) cumsum = 0 chosen_group = None for group, weight in items_with_weights: cumsum += weight if rand_val <= cumsum: chosen_group = group break if not chosen_group: chosen_group = items_with_weights[-1][0] variants = chosen_group["variants"] base_item = random.choice(variants) if variants else None return chosen_group, base_item @app.post("/web/api/cases/open/slot") async def api_open_slot_case( case_name: str = Form(...), free_spin: str = Form(""), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Слот-машина: 3 барабана, совпадение = приз""" case_config = CASES_CONFIG.get(case_name, {}) price_per_case = case_config.get('price_open', 250) is_free = free_spin == "1" if not is_free and user.balance < price_per_case: return JSONResponse(status_code=400, content={ "error": f"Недостаточно средств. Нужно {price_per_case:.2f} ₽" }) grouped_items = get_case_items_grouped(case_name) if not grouped_items or len(grouped_items) < 2: return JSONResponse(status_code=400, content={"error": "В кейсе недостаточно предметов"}) adjusted_weights = await get_adjusted_weights(db, user.id) # Буст для слотов: чаще выпадают активки SLOT_RARITY_BOOST = { "Covert": 8, "Classified": 4, "Restricted": 2, "Rare Special Item": 12, "Extraordinary": 10 } for rarity, boost in SLOT_RARITY_BOOST.items(): if rarity in adjusted_weights: adjusted_weights[rarity] *= boost # Баним: принудительно разные группы на всех барабанах if user.is_banned: group1, item1 = pick_slot_reel(grouped_items, adjusted_weights) group2, item2 = pick_slot_reel(grouped_items, adjusted_weights, {group1["base_name"]}) group3, item3 = pick_slot_reel(grouped_items, adjusted_weights, {group1["base_name"], group2["base_name"]}) if not item3: group3, item3 = pick_slot_reel(grouped_items, adjusted_weights, {group1["base_name"]}) else: group1, item1 = pick_slot_reel(grouped_items, adjusted_weights) group2, item2 = pick_slot_reel(grouped_items, adjusted_weights) group3, item3 = pick_slot_reel(grouped_items, adjusted_weights) def resolve_reel(group, item): if not item or not group: return None name_key = item.get("market_hash_name", "").lower().strip() id_list = NAME_LOWER_TO_IDS.get(name_key) real_id = id_list[0] if id_list else None return { "id": real_id or 0, "name": item.get("market_hash_name", "???"), "image_url": item.get("image_url", ""), "rarity": group["rarity"], "base_name": group["base_name"] } reels = [resolve_reel(group1, item1), resolve_reel(group2, item2), resolve_reel(group3, item3)] reels = [r for r in reels if r] # Assign activations to each reel's target item ACTIVATION_WEIGHTS = [ ("extra_spin", 0.10), ("double", 0.04), ("guaranteed", 0.07), ("free_spin", 0.07), ("quintuple", 0.02), ] def pick_activation(): r = random.random() cum = 0 for name, w in ACTIVATION_WEIGHTS: cum += w if r < cum: return name return "" reel_activations = [pick_activation() for _ in range(3)] activations_str = ', '.join(a if a else 'none' for a in reel_activations) print(f"[SLOT] activations: {activations_str}") match = False prize_data = None bonus_data = None prize_price = 0 bonus_price = 0 multiplier = 1 # 1 = normal, 2 = 2x, 5 = 5x multiplied_prize = None if len(reels) == 3: base_names = [r["base_name"] for r in reels] match = len(set(base_names)) == 1 def make_item(item_data, item_id, base_name, wear, item_float, source): display_name = f"{base_name} ({wear})" return InventoryItem( user_id=user.id, item_id=item_id, market_hash_name=display_name, rarity=item_data.get("rarity", "Unknown"), wear=wear, float_value=item_float, type=item_data.get("type", "Normal"), image_url=item_data.get("image_url", ""), price_rub=item_data.get("price_rub", 0), obtained_from=source ) def generate_wear(item): min_f = item.get("min_float", item.get("wear_range", [0, 1])[0]) max_f = item.get("max_float", item.get("wear_range", [0, 1])[1]) f = round(random.uniform(min_f, max_f), 6) return f, get_wear_from_float(f) if match: for act in reel_activations: if act == "quintuple": multiplier = 5 break elif act == "double": multiplier = 2 break matched_name = reels[0]["name"] prize_item = None for g in grouped_items: if g["base_name"] == reels[0]["base_name"]: variants = g["variants"] prize_item = random.choice(variants) if variants else None break if prize_item: prize_float, prize_wear = generate_wear(prize_item) prize_id = item_id_by_name(prize_item.get("market_hash_name")) prize_price = prize_item.get("price_rub", 0) target_min_price = price_per_case * 1.5 candidates = [] for g in grouped_items: for v in g["variants"]: vp = v.get("price_rub", 0) if vp >= target_min_price: candidates.append((vp, v, g)) if candidates: candidates.sort(key=lambda x: x[0]) bonus_price, bonus_variant, bonus_group = candidates[0] bonus_float, bonus_wear = generate_wear(bonus_variant) bonus_id = item_id_by_name(bonus_variant.get("market_hash_name")) bonus_data = { "id": bonus_id or bonus_variant.get("_id", 0), "name": bonus_variant.get("market_hash_name", "???"), "image_url": bonus_variant.get("image_url", ""), "rarity": bonus_group["rarity"], "price": bonus_price, "float": bonus_float, "wear": bonus_wear } if multiplier > 1: total_value = (prize_price + bonus_price) * multiplier best_item = None best_diff = float('inf') for idx, it in enumerate(ALL_ITEMS): ip = it.get("price_rub", 0) if ip <= 0: continue diff = abs(ip - total_value) if diff < best_diff: best_diff = diff best_item = it if best_item: mult_float, mult_wear = generate_wear(best_item) multiplied_id = item_id_by_name(best_item.get("market_hash_name")) multiplied_prize = { "id": multiplied_id or best_item.get("_id", 0), "name": best_item.get("market_hash_name", "???"), "image_url": best_item.get("image_url", ""), "rarity": best_item.get("rarity", "Unknown"), "price": best_item.get("price_rub", 0), "float": mult_float, "wear": mult_wear } prize_data = { "id": prize_id or prize_item.get("_id", 0), "name": prize_item.get("market_hash_name", "???"), "image_url": prize_item.get("image_url", ""), "rarity": prize_item.get("rarity", "Unknown"), "price": prize_price, "float": prize_float, "wear": prize_wear } db.add(make_item(prize_item, prize_data["id"], reels[0]["base_name"], prize_data["wear"], prize_data["float"], f"slot: {case_name}")) db.add(CaseOpening( user_id=user.id, case_name=case_name, item_id=prize_data["id"], item_name=prize_data["name"], rarity=prize_data["rarity"], float_value=prize_data["float"] )) if bonus_data: bonus_item_data = {"rarity": bonus_data["rarity"], "type": "Normal"} db.add(make_item(bonus_item_data, bonus_data["id"], bonus_data["name"].rsplit(" (", 1)[0] if " (" in bonus_data["name"] else bonus_data["name"], bonus_data["wear"], bonus_data["float"], f"slot_bonus: {case_name}")) db.add(CaseOpening( user_id=user.id, case_name=case_name, item_id=bonus_data["id"], item_name=bonus_data["name"], rarity=bonus_data["rarity"], float_value=bonus_data["float"] )) if multiplied_prize: mult_item_data = {"rarity": multiplied_prize["rarity"], "type": "Normal"} db.add(make_item(mult_item_data, multiplied_prize["id"], multiplied_prize["name"].rsplit(" (", 1)[0] if " (" in multiplied_prize["name"] else multiplied_prize["name"], multiplied_prize["wear"], multiplied_prize["float"], f"slot_mult{multiplier}: {case_name}")) db.add(CaseOpening( user_id=user.id, case_name=case_name, item_id=multiplied_prize["id"], item_name=multiplied_prize["name"], rarity=multiplied_prize["rarity"], float_value=multiplied_prize["float"] )) elif "guaranteed" in reel_activations: guessed_group, guessed_item = pick_slot_reel(grouped_items, adjusted_weights) if guessed_item and guessed_group: g_price = guessed_item.get("price_rub", 0) if g_price > 0: g_float, g_wear = generate_wear(guessed_item) prize_price = g_price prize_data = { "id": guessed_item.get("_id", 0), "name": guessed_item.get("market_hash_name", "???"), "image_url": guessed_item.get("image_url", ""), "rarity": guessed_group["rarity"], "price": prize_price, "float": g_float, "wear": g_wear } db.add(make_item( {"rarity": guessed_group["rarity"], "type": "Normal"}, prize_data["id"], guessed_group["base_name"], prize_data["wear"], prize_data["float"], f"slot_guaranteed: {case_name}" )) db.add(CaseOpening( user_id=user.id, case_name=case_name, item_id=prize_data["id"], item_name=prize_data["name"], rarity=prize_data["rarity"], float_value=prize_data["float"] )) if not is_free: user.balance -= price_per_case await update_rpu_stats(db, user.id, price_per_case, 1) # Проверка достижений для слота unlocked_ach = [] if match: unlocked_ach += await check_slot_match_achievements(db, user.id) unlocked_ach += await check_slot_plays_achievements(db, user.id) unlocked_ach += await check_slot_match_count_achievements(db, user.id) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) await db.commit() return JSONResponse({ "success": True, "achievements_unlocked": unlocked_ach if unlocked_ach else None, "reels": reels, "match": match, "prize": prize_data, "bonus": bonus_data, "prize_value": prize_price, "bonus_value": bonus_price, "spent": 0 if is_free else price_per_case, "activations": reel_activations, "multiplier": multiplier if multiplier > 1 else 0, "multiplied_prize": multiplied_prize }) @app.post("/web/api/cases/open/multiple") async def api_open_multiple_cases( case_name: str = Form(...), count: int = Form(...), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Открытие нескольких кейсов с группировкой и РПУ""" # Определяем максимальное количество в зависимости от типа кейса is_slot = "slot" in case_name.lower() or "слот" in case_name.lower() is_farm = "фарм" in case_name.lower() or "farm" in case_name.lower() max_allowed = 1 if is_slot else (100 if is_farm else 10) if count < 1 or count > max_allowed: return JSONResponse(status_code=400, content={ "error": f"Количество должно быть от 1 до {max_allowed}" }) case_config = CASES_CONFIG.get(case_name, {}) price_per_case = case_config.get('price_open', 250) total_price = price_per_case * count if user.balance < total_price: return JSONResponse(status_code=400, content={ "error": f"Недостаточно средств. Нужно {total_price:.2f} ₽, у вас {user.balance:.2f} ₽" }) # Подготовка для бана: ищем самый дешёвый предмет в кейсе cheapest_case_item = None if user.is_banned: for group in get_case_items_grouped(case_name): for v in group["variants"]: v_price = v.get("price_rub", 0) if cheapest_case_item is None or v_price < cheapest_case_item["price"]: v_id = item_id_by_name(v.get("market_hash_name")) cheapest_case_item = { "id": v_id or v.get("_id", 0), "item": v, "price": v_price, "base_name": group["base_name"], "rarity": group["rarity"] } # Включаем batch-режим — все sub-функции делают flush вместо commit import rpu as _rpu_mod _rpu_mod._BATCH_MODE = True try: # Один раз считаем RPU на всю пачку (кэшируется внутри) adjusted_weights = await get_adjusted_weights(db, user.id) results = [] for _ in range(count): result = open_case_with_variants_rpu(case_name, adjusted_weights) if result: item_data = result["item"] item_float = result["float"] item_id = result["id"] base_name = result["group"]["base_name"] # Бан: выдаём самый дешёвый предмет если выпал дороже 75% цены кейса if user.is_banned and cheapest_case_item: item_price = item_data.get("price_rub", 0) max_allowed_price = price_per_case * 0.75 if item_price > max_allowed_price: ci = cheapest_case_item item_data = ci["item"] item_id = ci["id"] item_float = round(random.uniform(0.01, 0.45), 6) base_name = ci["base_name"] wear = "Field-Tested" wear = item_data.get("wear", "Field-Tested") display_name = f"{base_name} ({wear})" if item_data.get("type") == "StatTrak": display_name = f"StatTrak™ {display_name}" elif item_data.get("type") == "Souvenir": display_name = f"Souvenir {display_name}" price = item_data.get("price_rub", 0) or 100 inventory_item = InventoryItem( user_id=user.id, item_id=item_id, market_hash_name=display_name, rarity=item_data.get("rarity", "Unknown"), wear=wear, float_value=item_float, type=item_data.get("type", "Normal"), image_url=item_data.get("image_url", ""), price_rub=price, obtained_from=f"case: {case_name}" ) db.add(inventory_item) opening = CaseOpening( user_id=user.id, case_name=case_name, item_id=item_id, item_name=display_name, rarity=item_data.get("rarity", "Unknown"), float_value=item_float ) db.add(opening) results.append({ "id": item_id, "name": display_name, "rarity": item_data.get("rarity"), "float": item_float, "image_url": item_data.get("image_url", ""), "wear": wear, "price": price }) user.balance -= total_price # Обновляем статистику РПУ total_received = sum(r.get("price", 0) for r in results) had_rare = any(r.get("rarity") in ("Covert", "Rare Special Item", "Extraordinary") for r in results) await update_rpu_stats(db, user.id, total_price, count, total_received, rarity=results[0]["rarity"] if results else None, is_rare=had_rare) await db.commit() finally: _rpu_mod._BATCH_MODE = False _rpu_mod._batch_cache_clear() # Запись активности — каждый предмет отдельно for r in results: item_price = r.get("price", 0) mult = round(item_price / max(1, price_per_case), 1) if item_price > 0 else 0 effect = f"drop:{mult}x" if mult >= 3 else None act_data = { "case": case_name, "item": r["name"], "rarity": r.get("rarity", ""), "item_image": r.get("image_url", ""), "mult": mult } if effect: act_data["effect"] = effect act = record_activity_own_session(user.id, user.username, "case_open", f"📦 открыл(а) кейс и получил(а) {r['name']}", act_data) try: asyncio.ensure_future(manager.broadcast({ "type": "activity", "activity": act })) except: pass # Проверка достижений unlocked_ach = [] unlocked_ach += await check_open_cases_achievements(db, user.id) user_rpu = await get_user_rpu(db, user.id) unlocked_ach += await check_spent_achievements(db, user.id, user_rpu.total_spent) unlocked_ach += await check_inventory_achievements(db, user.id) unlocked_ach += await check_dildo_achievements(db, user.id) unlocked_ach += await check_items_unboxed_achievements(db, user.id) unlocked_ach += await check_rare_item_count_achievements(db, user.id) unlocked_ach += await check_knife_count_achievements(db, user.id) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) for r in results: unlocked_ach += await check_rare_item_achievement(db, user.id, r.get("rarity", "")) item_full = get_item(r.get("id", 0)) if item_full: unlocked_ach += await check_knife_achievement(db, user.id, item_full) asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "results": results, "count": len(results), "spent": total_price, "new_balance": user.balance, "achievements_unlocked": unlocked_ach if unlocked_ach else None }) @app.post("/web/api/inventory/sell") async def api_sell_item( inventory_id: int = Form(...), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Продажа предмета из инвентаря""" result = await db.execute( select(InventoryItem).filter( InventoryItem.id == inventory_id, InventoryItem.user_id == user.id ) ) inv_item = result.scalar_one_or_none() if not inv_item: return JSONResponse(status_code=400, content={"error": "Предмет не найден"}) # Получаем цену предмета (используем сохранённую при получении, не из ALL_ITEMS) price = inv_item.price_rub if price <= 0: item_data = get_item(inv_item.item_id) if item_data: price = item_data.get('price_rub', 0) if price <= 0: price = 100 # Минимальная цена если не указана # Начисляем деньги user.balance += price # Удаляем предмет await db.delete(inv_item) await db.commit() asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "sold_price": price, "new_balance": user.balance, "message": f"Предмет продан за {price:.2f} ₽" }) @app.post("/web/api/inventory/sell/bulk") async def api_sell_bulk_items( inventory_ids: str = Form(...), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): """Массовая продажа предметов из инвентаря""" try: ids = json.loads(inventory_ids) except: return JSONResponse(status_code=400, content={"error": "Неверный формат ID"}) if not ids: return JSONResponse(status_code=400, content={"error": "Не выбрано ни одного предмета"}) # Получаем предметы result = await db.execute( select(InventoryItem).filter( InventoryItem.id.in_(ids), InventoryItem.user_id == user.id ) ) items_to_sell = result.scalars().all() if not items_to_sell: return JSONResponse(status_code=400, content={"error": "Предметы не найдены"}) total_received = 0 sold_count = 0 for inv_item in items_to_sell: price = inv_item.price_rub if price <= 0: item_data = get_item(inv_item.item_id) if item_data: price = item_data.get('price_rub', 0) if price <= 0: price = 100 total_received += price sold_count += 1 # Удаляем предмет await db.delete(inv_item) # Начисляем деньги user.balance += total_received await db.commit() asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "sold_count": sold_count, "total_received": total_received, "new_balance": user.balance }) @app.get("/upgrade", response_class=HTMLResponse) async def upgrade_page( request: Request, db: Session = Depends(get_db), user: Optional[User] = Depends(get_current_user_optional) ): """Страница апгрейдов""" enriched_items = [] upgrade_rpu = None total_attempts = 0 total_success = 0 success_rate = 0 recent_upgrades = [] if user: # Получаем предметы из инвентаря inventory_items_db = db.query(InventoryItem).filter( InventoryItem.user_id == user.id ).order_by(desc(InventoryItem.obtained_at)).all() # Обогащаем предметы данными из ALL_ITEMS for item in inventory_items_db: item_data = get_item(item.item_id) if item_data: enriched_items.append({ "id": item.id, "item_id": item.item_id, "name": item.market_hash_name, "rarity": item.rarity, "price_rub": item_data.get("price_rub", 0) or 0, "image_url": item_data.get("image_url", ""), "wear": item.wear, "float": item.float_value }) # Получаем РПУ для апгрейдов upgrade_rpu = get_upgrade_rpu(db, user.id) # Статистика total_attempts = upgrade_rpu.total_attempts total_success = upgrade_rpu.total_success success_rate = (total_success / total_attempts * 100) if total_attempts > 0 else 0 # Последние апгрейды recent_rows = db.query(Upgrade).filter( Upgrade.user_id == user.id ).order_by(desc(Upgrade.created_at)).limit(20).all() for u in recent_rows: input_img = u.input_item_image_url or "" target_img = u.target_item_image_url or "" if not input_img: idata = get_item(u.input_item_id) if idata: input_img = idata.get("image_url", "") if not target_img: tdata = get_item(u.target_item_id) if tdata: target_img = tdata.get("image_url", "") recent_upgrades.append({ "id": u.id, "success": u.success, "input_item_id": u.input_item_id, "input_item_name": u.input_item_name or "", "input_image_url": input_img, "target_item_id": u.target_item_id, "target_item_name": u.target_item_name or "", "target_image_url": target_img, "probability": round(u.rpu_adjusted_probability or u.probability or 0, 1) }) return templates.TemplateResponse(request, "upgrade.html", { "user": user, "inventory_items": enriched_items, "upgrade_rpu": upgrade_rpu, "total_attempts": total_attempts, "total_success": total_success, "success_rate": round(success_rate, 1), "recent_upgrades": recent_upgrades, "active_page": "upgrade" }) @app.post("/web/api/upgrade/calculate") async def api_calculate_upgrade( input_inventory_id: int = Form(...), target_item_id: int = Form(...), db: Session = Depends(get_db), user: User = Depends(get_current_user) ): """Рассчитать шанс апгрейда""" # Получаем входной предмет input_item = db.query(InventoryItem).filter( InventoryItem.id == input_inventory_id, InventoryItem.user_id == user.id ).first() if not input_item: return JSONResponse(status_code=400, content={"error": "Предмет не найден"}) # Получаем данные предметов (O(1) через ITEM_BY_ID) input_data = get_item(input_item.item_id) target_data = get_item(target_item_id) if not input_data or not target_data: return JSONResponse(status_code=400, content={"error": "Данные предметов не найдены"}) input_price = input_data.get("price_rub", 100) target_price = target_data.get("price_rub", 100) if target_price <= input_price: return JSONResponse(status_code=400, content={ "error": f"Нельзя апгрейдить в более дешёвый предмет! ({input_price:.0f} ₽ → {target_price:.0f} ₽)" }) base_probability = calculate_upgrade_probability(input_price, target_price) adjusted_probability = get_adjusted_upgrade_probability(db, user.id, base_probability) return JSONResponse({ "success": True, "input_item": { "id": input_item.id, "name": input_item.market_hash_name, "price": input_price, "image_url": input_data.get("image_url", "") }, "target_item": { "id": target_item_id, "name": target_data.get("market_hash_name", "Unknown"), "price": target_price, "image_url": target_data.get("image_url", "") }, "base_probability": round(base_probability, 2), "adjusted_probability": round(adjusted_probability, 2), "rpu_multiplier": get_upgrade_rpu(db, user.id).upgrade_multiplier }) @app.get("/web/api/upgrade/history") async def api_upgrade_history( db: Session = Depends(get_db), user: User = Depends(get_current_user) ): recent = db.query(Upgrade).filter( Upgrade.user_id == user.id ).order_by(desc(Upgrade.created_at)).limit(20).all() items = [] for u in recent: input_img = u.input_item_image_url or "" target_img = u.target_item_image_url or "" if not input_img: idata = get_item(u.input_item_id) if idata: input_img = idata.get("image_url", "") if not target_img: tdata = get_item(u.target_item_id) if tdata: target_img = tdata.get("image_url", "") items.append({ "id": u.id, "success": u.success, "input_item_id": u.input_item_id, "input_item_name": u.input_item_name or "", "input_image_url": input_img, "target_item_id": u.target_item_id, "target_item_name": u.target_item_name or "", "target_image_url": target_img, "probability": round(u.rpu_adjusted_probability or u.probability or 0, 1) }) return JSONResponse({"success": True, "history": items}) @app.post("/web/api/upgrade/execute") async def api_execute_upgrade( input_inventory_id: int = Form(...), target_item_id: int = Form(...), quick_mode: bool = Form(False), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): result = await db.execute( select(InventoryItem).filter( InventoryItem.id == input_inventory_id, InventoryItem.user_id == user.id ) ) input_item = result.scalar_one_or_none() if not input_item: return JSONResponse(status_code=400, content={"error": "Предмет не найден"}) input_data = get_item(input_item.item_id) target_data = get_item(target_item_id) if not input_data or not target_data: return JSONResponse(status_code=400, content={"error": "Данные предметов не найдены"}) input_price = input_data.get("price_rub", 100) target_price = target_data.get("price_rub", 100) if target_price <= input_price: return JSONResponse(status_code=400, content={ "error": f"Нельзя апгрейдить в более дешёвый предмет!" }) base_probability = calculate_upgrade_probability(input_price, target_price) adjusted_probability = await get_adjusted_upgrade_probability_async(db, user.id, base_probability) # Бан: колесо падает аккурат на 1-15° после зелёной зоны (как будто был шанс) if user.is_banned: half_green = (adjusted_probability / 100) * 180 green_end = 180 + half_green target_angle = min(360, green_end + random.uniform(1, 15)) rotations = random.randint(1, 3) if quick_mode else random.randint(6, 8) final_angle = target_angle + rotations * 360 success = False else: success, final_angle, rotations, _ = spin_upgrade_wheel(adjusted_probability) if quick_mode: rotations = random.randint(1, 3) final_angle = (final_angle % 360) + rotations * 360 # Сохраняем поля до удаления saved_input_name = input_item.market_hash_name saved_input_item_id = input_item.item_id await db.delete(input_item) if success: item_float = target_data.get("mid_float_used") or generate_item_float(target_data.get("rarity", "Unknown")) new_item = InventoryItem( user_id=user.id, item_id=target_item_id, market_hash_name=target_data.get("market_hash_name", "Unknown"), rarity=target_data.get("rarity", "Unknown"), wear=target_data.get("wear", "Unknown"), float_value=item_float, type=target_data.get("type", "Normal"), image_url=target_data.get("image_url", ""), price_rub=target_data.get("price_rub", 0), obtained_from="upgrade" ) db.add(new_item) # Записываем апгрейд upgrade = Upgrade( user_id=user.id, input_item_id=input_item.item_id, input_item_name=saved_input_name, input_item_image_url=input_data.get("image_url", ""), target_item_id=target_item_id, target_item_name=target_data.get("market_hash_name", "Unknown"), target_item_image_url=target_data.get("image_url", ""), success=success, probability=base_probability if not user.is_banned else calculate_upgrade_probability(input_price, target_price), rpu_adjusted_probability=adjusted_probability ) db.add(upgrade) # Обновляем статистику import rpu as _rpu_mod _rpu_mod._BATCH_MODE = True try: await update_upgrade_stats_async(db, user.id, success, input_price) unlocked_ach = await check_upgrade_achievements(db, user.id) unlocked_ach += await check_upgrade_risk_achievements(db, user.id, input_price) unlocked_ach += await check_upgrade_result_achievements(db, user.id, success, base_probability, input_price) unlocked_ach += await check_inventory_achievements(db, user.id) unlocked_ach += await check_dildo_achievements(db, user.id) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_collection_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) if success: prob_pct = round(base_probability, 1) if base_probability > 0 else 0 effect = f"upgrade:{prob_pct}%" if prob_pct <= 25 and prob_pct > 0 else None act_data = { "input": saved_input_name, "target": target_data.get("market_hash_name", ""), "success": True, "item_image": target_data.get("image_url", ""), "probability": prob_pct } if effect: act_data["effect"] = effect act = record_activity_own_session(user.id, user.username, "upgrade", f"✅ выиграл(а) апгрейд: {saved_input_name} → {target_data.get('market_hash_name', '???')}", act_data, db=db) try: asyncio.ensure_future(manager.broadcast({ "type": "activity", "activity": act })) except: pass finally: _rpu_mod._BATCH_MODE = False await db.commit() asyncio.ensure_future(manager.send_personal(user.id, {"type": "inventory_update"})) asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "upgrade_success": success, "final_angle": final_angle, "rotations": rotations, "probability": round(adjusted_probability, 2), "input_item": { "name": input_item.market_hash_name, "image_url": input_data.get("image_url", ""), "price": input_price, "rarity": input_item.rarity }, "received_item": { "name": target_data.get("market_hash_name"), "image_url": target_data.get("image_url", ""), "price": target_price, "rarity": target_data.get("rarity") } if success else None, "achievements_unlocked": unlocked_ach if unlocked_ach else None }) # ═══════════════════════════════════════════════════════════════════════════════ # 🏆 Достижения # ═══════════════════════════════════════════════════════════════════════════════ @app.get("/achievements", response_class=HTMLResponse) async def achievements_page( request: Request, db: Session = Depends(get_db), user: User = Depends(get_current_user) ): achievements = get_user_achievements(db, user.id) total = len(achievements) unlocked = sum(1 for a in achievements if a["unlocked"]) return templates.TemplateResponse(request, "achievements.html", { "user": user, "achievements": achievements, "total": total, "unlocked": unlocked, "active_page": "achievements" }) @app.get("/web/api/achievements") async def api_get_achievements( db: Session = Depends(get_db), user: User = Depends(get_current_user) ): return JSONResponse({ "success": True, "achievements": get_user_achievements(db, user.id) }) @app.get("/web/api/activity") async def api_get_activity( limit: int = 50, db: Session = Depends(get_db), user: Optional[User] = Depends(get_current_user_optional) ): activities = db.query(ActivityFeed).order_by(desc(ActivityFeed.created_at)).limit(limit).all() return JSONResponse({ "success": True, "activities": [ { "id": a.id, "user_id": a.user_id, "username": a.username, "activity_type": a.activity_type, "message": a.message, "data": json.loads(a.data_json) if a.data_json else {}, "created_at": a.created_at.isoformat() } for a in activities ] }) # ═══════════════════════════════════════════════════════════════════════════════ # 💥 Crash Game # ═══════════════════════════════════════════════════════════════════════════════ async def crash_game_loop(): while True: g = crash_game g.round += 1 g.phase = "betting" g.timer = 12 g.bets = {} g.cashed_out = {} while g.timer > 0: await manager.broadcast({ "type": "crash_state", "game": g.to_dict() }) await asyncio.sleep(1) g.timer -= 1 if not g.bets: g.phase = "waiting" await asyncio.sleep(2) continue g.phase = "running" g.crash_point = g.generate_crash_point() g.current_multiplier = 1.0 g._start_time = asyncio.get_event_loop().time() while True: g._elapsed = asyncio.get_event_loop().time() - g._start_time g.current_multiplier = g.get_multiplier_at_time(g._elapsed) if g.current_multiplier >= g.crash_point: g.current_multiplier = g.crash_point break await manager.broadcast({ "type": "crash_state", "game": g.to_dict() }) # Чем выше множитель, тем реже обновляем (для производительности) if g.current_multiplier < 2: await asyncio.sleep(0.03) elif g.current_multiplier < 5: await asyncio.sleep(0.05) elif g.current_multiplier < 10: await asyncio.sleep(0.08) else: await asyncio.sleep(0.12) g.phase = "crashed" await manager.broadcast({ "type": "crash_state", "game": g.to_dict() }) # Выплаты тем кто вывел for uid, cashout_mult in g.cashed_out.items(): bet = g.bets.get(uid, 0) if bet > 0: from database import User as CrUser db_c = next(get_db()) u = db_c.query(CrUser).filter(CrUser.id == uid).first() if u: payout = g.calculate_payout(bet, cashout_mult) try: u.balance += payout db_c.commit() except: db_c.rollback() act = record_activity_own_session(uid, u.username, "crash", f"💥 {u.username} выиграл(а) {payout:.0f} ₽ в Crash (x{cashout_mult})", {"payout": payout, "multiplier": cashout_mult}) try: asyncio.ensure_future(manager.broadcast({ "type": "activity", "activity": act })) except: pass db_c.close() g.history.append(g.crash_point) g.phase = "waiting" await asyncio.sleep(4) from contextlib import asynccontextmanager @asynccontextmanager async def lifespan(app_instance): asyncio.create_task(crash_game_loop()) # Генерируем первый авто-промокод при старте try: from database import SessionLocal db = SessionLocal() from promo_service import get_or_create_auto_promo get_or_create_auto_promo(db) db.close() except Exception: pass yield app.router.lifespan_context = lifespan @app.get("/crash", response_class=HTMLResponse) async def crash_page( request: Request, user: User = Depends(get_current_user) ): return templates.TemplateResponse(request, "crash.html", { "user": user, "active_page": "crash" }) @app.post("/web/api/crash/bet") async def api_crash_bet( amount: float = Form(...), db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): g = crash_game if g.phase != "betting": return JSONResponse(status_code=400, content={"error": "Ставки закрыты"}) if amount <= 0: return JSONResponse(status_code=400, content={"error": "Неверная сумма"}) if user.balance < amount: return JSONResponse(status_code=400, content={"error": "Недостаточно средств"}) user.balance -= amount g.bets[user.id] = g.bets.get(user.id, 0) + amount # Проверка достижений from database import ActivityFeed as CrActivity crash_count_result = await db.execute( select(sa_func.count(CrActivity.id)).filter( CrActivity.user_id == user.id, CrActivity.activity_type == "crash" ) ) crash_count = crash_count_result.scalar() + 1 unlocked_ach = await check_crash_achievements(db, user.id, crash_count) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) await db.commit() asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "bet": g.bets[user.id], "new_balance": user.balance, "achievements_unlocked": unlocked_ach if unlocked_ach else None }) @app.post("/web/api/crash/cashout") async def api_crash_cashout( db: AsyncSession = Depends(get_async_db), user: User = Depends(get_current_user) ): g = crash_game if g.phase != "running": return JSONResponse(status_code=400, content={"error": "Игра не в активной фазе"}) if user.id not in g.bets: return JSONResponse(status_code=400, content={"error": "У вас нет активной ставки"}) if user.id in g.cashed_out: return JSONResponse(status_code=400, content={"error": "Вы уже вывели"}) g.cashed_out[user.id] = g.current_multiplier payout = g.calculate_payout(g.bets[user.id], g.current_multiplier) # Сразу начисляем user.balance += payout # Проверка достижений unlocked_ach = await check_crash_cashout_achievements(db, user.id, g.current_multiplier) unlocked_ach += await check_balance_achievements(db, user.id) unlocked_ach += await check_achievements_count_achievements(db, user.id) await db.commit() asyncio.ensure_future(manager.send_personal(user.id, {"type": "balance_update", "balance": user.balance})) return JSONResponse({ "success": True, "multiplier": g.current_multiplier, "payout": payout, "new_balance": user.balance, "achievements_unlocked": unlocked_ach if unlocked_ach else None }) # ─── Запуск ──────────────────────────────────────────────────────────────── if __name__ == "__main__": import uvicorn make_first_user_admin() reset_pidor_password() uvicorn.run(app, host="0.0.0.0", port=13669)