main features

2025-08-10 17:28:38 +09:00
parent 3e4a21d5b1
commit 95bef94c53
30 changed files with 4246 additions and 1066 deletions
--- a/.patch_backup_20250810_160643/ui/api.py
+++ b/.patch_backup_20250810_160643/ui/api.py
@@ -0,0 +1,527 @@
+import logging
+import os
+import os.path
+import json
+import time
+import uuid
+from typing import Any, Dict, Optional, Tuple, List, Union
+
+import requests
+from django.conf import settings
+from django.core.exceptions import PermissionDenied
+
+logger = logging.getLogger(__name__)
+
+# ===== Логирование / флаги =====
+API_DEBUG = os.environ.get('API_DEBUG', '1') == '1'
+API_LOG_BODY_MAX = int(os.environ.get('API_LOG_BODY_MAX', '2000'))
+API_LOG_HEADERS = os.environ.get('API_LOG_HEADERS', '1') == '1'
+API_LOG_CURL = os.environ.get('API_LOG_CURL', '0') == '1'
+
+# Переключение базы при 404: сначала servers[0].url из openapi.json, потом жёстко http://localhost:8080
+API_FALLBACK_OPENAPI_ON_404 = os.environ.get('API_FALLBACK_OPENAPI_ON_404', '1') == '1'
+
+SENSITIVE_KEYS = {'password', 'refresh_token', 'access_token', 'authorization', 'token', 'api_key'}
+
+
+def _sanitize(obj: Any) -> Any:
+    try:
+        if isinstance(obj, dict):
+            return {k: ('***' if isinstance(k, str) and k.lower() in SENSITIVE_KEYS else _sanitize(v))
+                    for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [_sanitize(x) for x in obj]
+        return obj
+    except Exception:
+        return obj
+
+
+def _shorten(s: str, limit: int) -> str:
+    if s is None:
+        return ''
+    return s if len(s) <= limit else (s[:limit] + f'... <truncated {len(s)-limit} chars>')
+
+
+def _build_curl(method: str, url: str, headers: Dict[str, str],
+                params: Optional[dict], json_body: Optional[dict], data: Optional[dict]) -> str:
+    parts = [f"curl -X '{method.upper()}' \\\n  '{url}'"]
+    for k, v in headers.items():
+        if k.lower() == 'authorization':
+            v = 'Bearer ***'
+        parts.append(f"  -H '{k}: {v}'")
+    if json_body is not None:
+        parts.append("  -H 'Content-Type: application/json'")
+        try:
+            body_str = json.dumps(_sanitize(json_body), ensure_ascii=False)
+        except Exception:
+            body_str = str(_sanitize(json_body))
+        parts.append(f"  -d '{body_str}'")
+    elif data is not None:
+        try:
+            body_str = json.dumps(_sanitize(data), ensure_ascii=False)
+        except Exception:
+            body_str = str(_sanitize(data))
+        parts.append(f"  --data-raw '{body_str}'")
+    return " \\\n".join(parts)
+
+
+# ===== Пути эндпоинтов (как в swagger) =====
+EP_DEFAULTS: Dict[str, str] = {
+    # Auth
+    'AUTH_REGISTER_PATH': '/auth/v1/register',
+    'AUTH_TOKEN_PATH': '/auth/v1/token',
+    'AUTH_REFRESH_PATH': '/auth/v1/refresh',
+    'ME_PATH': '/auth/v1/me',
+    'USERS_LIST_PATH': '/auth/v1/users',
+    'USER_DETAIL_PATH': '/auth/v1/users/{user_id}',
+
+    # Profiles
+    'PROFILE_ME_PATH': '/profiles/v1/profiles/me',
+    'PROFILES_CREATE_PATH': '/profiles/v1/profiles',
+    'PROFILE_PHOTO_UPLOAD_PATH': '/profiles/v1/profiles/me/photo',
+    'PROFILE_PHOTO_DELETE_PATH': '/profiles/v1/profiles/me/photo',
+
+    # Pairs
+    'PAIRS_PATH': '/match/v1/pairs',
+    'PAIR_DETAIL_PATH': '/match/v1/pairs/{pair_id}',
+    'PAIR_ACCEPT_PATH': '/match/v1/pairs/{pair_id}/accept',
+    'PAIR_REJECT_PATH': '/match/v1/pairs/{pair_id}/reject',
+
+    # Chat
+    'ROOMS_PATH': '/chat/v1/rooms',
+    'ROOM_DETAIL_PATH': '/chat/v1/rooms/{room_id}',
+    'ROOM_MESSAGES_PATH': '/chat/v1/rooms/{room_id}/messages',
+
+    # Payments
+    'INVOICES_PATH': '/payments/v1/invoices',
+    'INVOICE_DETAIL_PATH': '/payments/v1/invoices/{inv_id}',
+    'INVOICE_MARK_PAID_PATH': '/payments/v1/invoices/{inv_id}/mark-paid',
+}
+
+def EP(key: str) -> str:
+    return os.environ.get(f'API_{key}', EP_DEFAULTS[key])
+
+
+# ===== База API с авто‑детектом =====
+_API_BASE_CACHE: Optional[str] = None
+_API_LAST_SELECT_SRC = 'DEFAULT'  # для логов
+
+def _detect_api_base_from_openapi() -> Optional[str]:
+    """
+    Берём servers[0].url из openapi.json (по схеме — http://localhost:8080).
+    """
+    candidates = [
+        os.environ.get('API_SPEC_PATH'),
+        getattr(settings, 'API_SPEC_PATH', None),
+        os.path.join(getattr(settings, 'BASE_DIR', ''), 'openapi.json') if getattr(settings, 'BASE_DIR', None) else None,
+        os.path.join(getattr(settings, 'BASE_DIR', ''), 'agency', 'openapi.json') if getattr(settings, 'BASE_DIR', None) else None,
+        '/mnt/data/openapi.json',
+    ]
+    for p in candidates:
+        if p and os.path.isfile(p):
+            try:
+                with open(p, 'r', encoding='utf-8') as f:
+                    spec = json.load(f)
+                servers = spec.get('servers') or []
+                if servers and isinstance(servers[0], dict):
+                    url = servers[0].get('url')
+                    if url:
+                        return url
+            except Exception as e:
+                if API_DEBUG:
+                    logger.debug('API: cannot read OpenAPI from %s: %s', p, e)
+    return None
+
+
+def _get_api_base_url() -> str:
+    """
+    Источники (по приоритету):
+    1) ENV/Settings: API_BASE_URL, затем BASE_URL
+    2) servers[0].url из openapi.json
+    3) 'http://localhost:8080'
+    """
+    global _API_BASE_CACHE, _API_LAST_SELECT_SRC
+    if _API_BASE_CACHE:
+        return _API_BASE_CACHE
+
+    base = (os.environ.get('API_BASE_URL') or getattr(settings, 'API_BASE_URL', '')
+            or os.environ.get('BASE_URL') or getattr(settings, 'BASE_URL', ''))
+    if base:
+        _API_BASE_CACHE = base.rstrip('/')
+        _API_LAST_SELECT_SRC = 'ENV/SETTINGS'
+    else:
+        detected = _detect_api_base_from_openapi()
+        if detected:
+            _API_BASE_CACHE = detected.rstrip('/')
+            _API_LAST_SELECT_SRC = 'OPENAPI'
+        else:
+            _API_BASE_CACHE = 'http://localhost:8080'
+            _API_LAST_SELECT_SRC = 'HARDCODED'
+
+    if API_DEBUG:
+        logger.info("API base selected [%s]: %s", _API_LAST_SELECT_SRC, _API_BASE_CACHE)
+    return _API_BASE_CACHE
+
+
+class ApiError(Exception):
+    def __init__(self, status: int, message: str = 'API error', payload: Optional[dict] = None, req_id: Optional[str] = None):
+        if req_id and message and 'req_id=' not in message:
+            message = f"{message} (req_id={req_id})"
+        super().__init__(message)
+        self.status = status
+        self.payload = payload or {}
+        self.req_id = req_id
+
+
+def _base_headers(request, extra: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+    """
+    Достаём токен сначала из сессии, затем из куки — чтобы «куки‑режим» работал без доп. настроек.
+    """
+    headers: Dict[str, str] = {'Accept': 'application/json'}
+    token = request.session.get('access_token') or request.COOKIES.get('access_token')
+    if token:
+        headers['Authorization'] = f'Bearer {token}'
+    api_key = getattr(settings, 'API_KEY', '') or os.environ.get('API_KEY', '')
+    if api_key:
+        headers['X-API-Key'] = api_key
+    if extra:
+        headers.update(extra)
+    return headers
+
+
+def _url(path: str) -> str:
+    base = _get_api_base_url()
+    path = path if path.startswith('/') else '/' + path
+    return base + path
+
+
+def request_api(
+    request,
+    method: str,
+    path: str,
+    *,
+    params: Optional[dict] = None,
+    json: Optional[dict] = None,
+    files: Optional[dict] = None,
+    data: Optional[dict] = None,
+) -> Tuple[int, Any]:
+    """
+    Универсальный HTTP-вызов (упрощённая версия):
+    - токен/ключ в заголовках (токен берём из сессии или куки),
+    - auto-refresh при 401 (refresh берём тоже из сессии или куки),
+    - 404 → переключаем базу: servers[0].url из openapi.json → 'http://localhost:8080',
+    - подробные логи; БЕЗ «retry со слэшем».
+    """
+    global _API_BASE_CACHE, _API_LAST_SELECT_SRC
+
+    req_id = uuid.uuid4().hex[:8]
+    base_before = _get_api_base_url()
+    url = _url(path)
+
+    def _do(_url: str):
+        headers = _base_headers(request)
+        if json is not None and files is None and data is None:
+            headers['Content-Type'] = 'application/json'
+
+        if API_DEBUG:
+            log_headers = _sanitize(headers) if API_LOG_HEADERS else {}
+            log_body = _sanitize(json if json is not None else data)
+            if API_LOG_CURL:
+                try:
+                    curl = _build_curl(method, _url, headers, params, json, data)
+                    logger.debug("API[req_id=%s] cURL:\n%s", req_id, curl)
+                except Exception:
+                    pass
+            logger.info(
+                "API[req_id=%s] REQUEST %s %s params=%s headers=%s body=%s",
+                req_id, method.upper(), _url, _sanitize(params), log_headers, log_body
+            )
+
+        t0 = time.time()
+        resp = requests.request(
+            method=method.upper(),
+            url=_url,
+            headers=headers,
+            params=params,
+            json=json,
+            data=data,
+            files=files,
+            timeout=float(getattr(settings, 'API_TIMEOUT', 8.0)),
+        )
+        dt = int((time.time() - t0) * 1000)
+
+        content_type = resp.headers.get('Content-Type', '')
+        try:
+            payload = resp.json() if 'application/json' in content_type else {}
+        except ValueError:
+            payload = {}
+
+        if API_DEBUG:
+            body_str = ""
+            try:
+                body_str = json.dumps(_sanitize(payload), ensure_ascii=False)
+            except Exception:
+                body_str = str(_sanitize(payload))
+            headers_out = _sanitize(dict(resp.headers)) if API_LOG_HEADERS else {}
+            logger.info(
+                "API[req_id=%s] RESPONSE %s %sms ct=%s headers=%s body=%s",
+                req_id, resp.status_code, dt, content_type, headers_out, _shorten(body_str, API_LOG_BODY_MAX)
+            )
+
+        return resp, payload
+
+    # 1) Первый запрос
+    try:
+        resp, payload = _do(url)
+    except requests.RequestException as e:
+        logger.exception('API[req_id=%s] network error: %s', req_id, e)
+        raise ApiError(0, f'Network unavailable or timeout when accessing API ({e})', req_id=req_id)
+
+    # 2) 404 → переключаем базу (openapi → 8080) и повторяем
+    if resp.status_code == 404:
+        candidates: List[tuple[str, str]] = []
+        if API_FALLBACK_OPENAPI_ON_404:
+            detected = _detect_api_base_from_openapi()
+            if detected:
+                candidates.append((detected.rstrip('/'), 'OPENAPI(FAILOVER)'))
+        candidates.append(('http://localhost:8080', 'DEFAULT(FAILOVER)'))
+
+        for cand_base, label in candidates:
+            if not cand_base or cand_base == _API_BASE_CACHE:
+                continue
+            if API_DEBUG:
+                logger.warning("API[req_id=%s] 404 on base %s → switch API base to %s and retry",
+                               req_id, _API_BASE_CACHE, cand_base)
+            _API_BASE_CACHE = cand_base
+            _API_LAST_SELECT_SRC = label
+            try:
+                resp, payload = _do(_url(path))
+                if resp.status_code != 404:
+                    break
+            except requests.RequestException:
+                continue
+
+    # 3) 401 → refresh и повтор
+    refresh_token = request.session.get('refresh_token') or request.COOKIES.get('refresh_token')
+    if resp.status_code == 401 and refresh_token:
+        if API_DEBUG:
+            logger.info("API[req_id=%s] 401 → try refresh token", req_id)
+        try:
+            refresh_url = _url(EP('AUTH_REFRESH_PATH'))
+            refresh_body = {'refresh_token': refresh_token}
+            logger.info("API[req_id=%s] REFRESH POST %s body=%s", req_id, refresh_url, _sanitize(refresh_body))
+            refresh_resp = requests.post(refresh_url, json=refresh_body, timeout=float(getattr(settings, 'API_TIMEOUT', 8.0)))
+            if refresh_resp.status_code == 200:
+                try:
+                    rj = refresh_resp.json()
+                except ValueError:
+                    rj = {}
+                if rj.get('access_token'):
+                    request.session['access_token'] = rj['access_token']
+                if rj.get('refresh_token'):
+                    request.session['refresh_token'] = rj['refresh_token']
+                request.session.modified = True
+                if API_DEBUG:
+                    logger.info("API[req_id=%s] REFRESH OK → retry original request", req_id)
+                resp, payload = _do(_url(path))
+            else:
+                logger.warning("API[req_id=%s] REFRESH failed: %s", req_id, refresh_resp.status_code)
+        except requests.RequestException as e:
+            logger.exception('API[req_id=%s] Refresh token network error: %s', req_id, e)
+            raise ApiError(401, f'Token refresh failed ({e})', req_id=req_id)
+
+    # 4) Ошибки
+    if not (200 <= resp.status_code < 300):
+        msg = None
+        if isinstance(payload, dict):
+            msg = payload.get('detail') or payload.get('message')
+        msg = msg or f'API error: {resp.status_code}'
+        if resp.status_code in (401, 403):
+            # PermissionDenied обрабатываем во view (не всегда это «выйти и войти заново»)
+            raise PermissionDenied(f"{msg} (req_id={req_id})")
+        raise ApiError(resp.status_code, msg, payload if isinstance(payload, dict) else {}, req_id=req_id)
+
+    # 5) База сменилась — отметим
+    base_after = _get_api_base_url()
+    if API_DEBUG and base_before != base_after:
+        logger.warning("API[req_id=%s] BASE SWITCHED: %s → %s", req_id, base_before, base_after)
+
+    return resp.status_code, payload
+
+
+# ==========================
+#           AUTH
+# ==========================
+
+def register_user(request, email: str, password: str, full_name: Optional[str] = None, role: str = 'CLIENT') -> Dict[str, Any]:
+    body = {'email': email, 'password': password, 'full_name': full_name, 'role': role}
+    _, data = request_api(request, 'POST', EP('AUTH_REGISTER_PATH'), json=body)
+    return data  # UserRead
+
+def login(request, email: str, password: str) -> Dict[str, Any]:
+    body = {'email': email, 'password': password}
+    _, data = request_api(request, 'POST', EP('AUTH_TOKEN_PATH'), json=body)
+    return data  # TokenPair
+
+def get_current_user(request) -> Dict[str, Any]:
+    _, data = request_api(request, 'GET', EP('ME_PATH'))
+    return data  # UserRead
+
+def list_users(request, offset: int = 0, limit: int = 50) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    params = {'offset': offset, 'limit': limit}
+    _, data = request_api(request, 'GET', EP('USERS_LIST_PATH'), params=params)
+    return data
+
+def get_user(request, user_id: str) -> Dict[str, Any]:
+    path = EP('USER_DETAIL_PATH').format(user_id=user_id)
+    _, data = request_api(request, 'GET', path)
+    return data
+
+def update_user(request, user_id: str, **fields) -> Dict[str, Any]:
+    path = EP('USER_DETAIL_PATH').format(user_id=user_id)
+    _, data = request_api(request, 'PATCH', path, json=fields)
+    return data
+
+def delete_user(request, user_id: str) -> None:
+    path = EP('USER_DETAIL_PATH').format(user_id=user_id)
+    request_api(request, 'DELETE', path)
+
+
+# ==========================
+#         PROFILES
+# ==========================
+
+def get_my_profile(request) -> Dict[str, Any]:
+    _, data = request_api(request, 'GET', EP('PROFILE_ME_PATH'))
+    return data  # ProfileOut
+
+def create_my_profile(request, gender: str, city: str, languages: List[str], interests: List[str]) -> Dict[str, Any]:
+    body = {'gender': gender, 'city': city, 'languages': languages, 'interests': interests}
+    _, data = request_api(request, 'POST', EP('PROFILES_CREATE_PATH'), json=body)
+    return data  # ProfileOut
+
+
+# ==========================
+#          PAIRS
+# ==========================
+
+def create_pair(request, user_id_a: str, user_id_b: str, score: Optional[float] = None, notes: Optional[str] = None) -> Dict[str, Any]:
+    body = {'user_id_a': user_id_a, 'user_id_b': user_id_b, 'score': score, 'notes': notes}
+    _, data = request_api(request, 'POST', EP('PAIRS_PATH'), json=body)
+    return data  # PairRead
+
+def list_pairs(request, for_user_id: Optional[str] = None, status: Optional[str] = None, offset: int = 0, limit: int = 50) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    params = {'for_user_id': for_user_id, 'status': status, 'offset': offset, 'limit': limit}
+    params = {k: v for k, v in params.items() if v is not None}
+    _, data = request_api(request, 'GET', EP('PAIRS_PATH'), params=params)
+    return data
+
+def get_pair(request, pair_id: str) -> Dict[str, Any]:
+    path = EP('PAIR_DETAIL_PATH').format(pair_id=pair_id)
+    _, data = request_api(request, 'GET', path)
+    return data
+
+def update_pair(request, pair_id: str, **fields) -> Dict[str, Any]:
+    path = EP('PAIR_DETAIL_PATH').format(pair_id=pair_id)
+    _, data = request_api(request, 'PATCH', path, json=fields)
+    return data
+
+def delete_pair(request, pair_id: str) -> None:
+    path = EP('PAIR_DETAIL_PATH').format(pair_id=pair_id)
+    request_api(request, 'DELETE', path)
+
+def accept_pair(request, pair_id: str) -> Dict[str, Any]:
+    path = EP('PAIR_ACCEPT_PATH').format(pair_id=pair_id)
+    _, data = request_api(request, 'POST', path)
+    return data
+
+def reject_pair(request, pair_id: str) -> Dict[str, Any]:
+    path = EP('PAIR_REJECT_PATH').format(pair_id=pair_id)
+    _, data = request_api(request, 'POST', path)
+    return data
+
+
+# ==========================
+#           CHAT
+# ==========================
+
+def my_rooms(request) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    _, data = request_api(request, 'GET', EP('ROOMS_PATH'))
+    return data
+
+def get_room(request, room_id: str) -> Dict[str, Any]:
+    path = EP('ROOM_DETAIL_PATH').format(room_id=room_id)
+    _, data = request_api(request, 'GET', path)
+    return data
+
+def create_room(request, title: Optional[str] = None, participants: List[str] = []) -> Dict[str, Any]:
+    body = {'title': title, 'participants': participants}
+    _, data = request_api(request, 'POST', EP('ROOMS_PATH'), json=body)
+    return data
+
+def send_message(request, room_id: str, content: str) -> Dict[str, Any]:
+    body = {'content': content}
+    path = EP('ROOM_MESSAGES_PATH').format(room_id=room_id)
+    _, data = request_api(request, 'POST', path, json=body)
+    return data
+
+def list_messages(request, room_id: str, offset: int = 0, limit: int = 100) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    params = {'offset': offset, 'limit': limit}
+    path = EP('ROOM_MESSAGES_PATH').format(room_id=room_id)
+    _, data = request_api(request, 'GET', path, params=params)
+    return data
+
+
+# ==========================
+#         PAYMENTS
+# ==========================
+
+def create_invoice(request, client_id: str, amount: float, currency: str, description: Optional[str] = None) -> Dict[str, Any]:
+    body = {'client_id': client_id, 'amount': amount, 'currency': currency, 'description': description}
+    _, data = request_api(request, 'POST', EP('INVOICES_PATH'), json=body)
+    return data
+
+def list_invoices(request, client_id: Optional[str] = None, status: Optional[str] = None, offset: int = 0, limit: int = 50) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    params = {'client_id': client_id, 'status': status, 'offset': offset, 'limit': limit}
+    params = {k: v for k, v in params.items() if v is not None}
+    _, data = request_api(request, 'GET', EP('INVOICES_PATH'), params=params)
+    return data
+
+def get_invoice(request, inv_id: str) -> Dict[str, Any]:
+    path = EP('INVOICE_DETAIL_PATH').format(inv_id=inv_id)
+    _, data = request_api(request, 'GET', path)
+    return data
+
+def update_invoice(request, inv_id: str, **fields) -> Dict[str, Any]:
+    path = EP('INVOICE_DETAIL_PATH').format(inv_id=inv_id)
+    _, data = request_api(request, 'PATCH', path, json=fields)
+    return data
+
+def delete_invoice(request, inv_id: str) -> None:
+    path = EP('INVOICE_DETAIL_PATH').format(inv_id=inv_id)
+    request_api(request, 'DELETE', path)
+
+def mark_invoice_paid(request, inv_id: str) -> Dict[str, Any]:
+    path = EP('INVOICE_MARK_PAID_PATH').format(inv_id=inv_id)
+    _, data = request_api(request, 'POST', path)
+    return data
+
+def upload_my_photo(request, file_obj) -> Dict[str, Any]:
+    """
+    Отправляет multipart/form-data на бекенд для загрузки фото профиля.
+    Ожидаем, что сервер примет поле 'file' и вернёт обновлённый профиль или {photo_url: "..."}.
+    """
+    path = EP('PROFILE_PHOTO_UPLOAD_PATH')
+    filename = getattr(file_obj, 'name', 'photo.jpg')
+    content_type = getattr(file_obj, 'content_type', 'application/octet-stream')
+    files = {'file': (filename, file_obj, content_type)}
+    _, data = request_api(request, 'POST', path, files=files)
+    return data
+
+def delete_my_photo(request) -> Dict[str, Any]:
+    """
+    Удаляет фото профиля (если сервер поддерживает DELETE на том же пути).
+    """
+    path = EP('PROFILE_PHOTO_DELETE_PATH')
+    _, data = request_api(request, 'DELETE', path)
+    return data