281 lines
11 KiB
Python
281 lines
11 KiB
Python
"""
|
|
Compatibility routes to preserve deprecated uploader-bot API surface (v1/system).
|
|
These endpoints mirror legacy paths so older clients continue to function,
|
|
while new v3 sync API works in parallel.
|
|
"""
|
|
|
|
import base64
|
|
import os
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, UploadFile, File, HTTPException, Query
|
|
from fastapi.responses import JSONResponse, StreamingResponse, PlainTextResponse
|
|
from sqlalchemy import text
|
|
import aiofiles
|
|
|
|
from app.core.logging import get_logger
|
|
from app.core.config import get_settings
|
|
from app.core.database import db_manager
|
|
from app.core.storage import LocalStorageBackend
|
|
|
|
router = APIRouter(prefix="", tags=["compat-v1"])
|
|
logger = get_logger(__name__)
|
|
settings = get_settings()
|
|
|
|
|
|
def _is_table_missing_error(exc: Exception) -> bool:
|
|
try:
|
|
msg = str(exc)
|
|
return 'UndefinedTable' in msg or 'does not exist' in msg or ('relation' in msg and 'does not exist' in msg)
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
@router.get("/api/system.version")
|
|
async def system_version():
|
|
codebase_hash = os.getenv("CODEBASE_HASH", "unknown")
|
|
codebase_branch = os.getenv("CODEBASE_BRANCH", os.getenv("GIT_BRANCH", "main"))
|
|
return {"codebase_hash": codebase_hash, "codebase_branch": codebase_branch}
|
|
|
|
|
|
@router.post("/api/system.sendStatus")
|
|
async def system_send_status(payload: dict):
|
|
try:
|
|
message_b58 = payload.get("message")
|
|
signature = payload.get("signature")
|
|
if not message_b58 or not signature:
|
|
raise HTTPException(status_code=400, detail="message and signature required")
|
|
await logger.ainfo("Compat system.sendStatus", signature=signature)
|
|
return {"ok": True}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
await logger.aerror("sendStatus failed", error=str(e))
|
|
raise HTTPException(status_code=500, detail="sendStatus failed")
|
|
|
|
|
|
@router.get("/api/tonconnect-manifest.json")
|
|
async def tonconnect_manifest():
|
|
host = str(getattr(settings, "PROJECT_HOST", "")) or os.getenv("PROJECT_HOST", "") or "http://localhost:8000"
|
|
return {
|
|
"url": host,
|
|
"name": "MY Network Node",
|
|
"iconUrl": f"{host}/static/icon.png",
|
|
"termsOfUseUrl": f"{host}/terms",
|
|
"privacyPolicyUrl": f"{host}/privacy",
|
|
"bridgeUrl": "https://bridge.tonapi.io/bridge",
|
|
"manifestVersion": 2
|
|
}
|
|
|
|
|
|
@router.get("/api/platform-metadata.json")
|
|
async def platform_metadata():
|
|
host = str(getattr(settings, "PROJECT_HOST", "")) or os.getenv("PROJECT_HOST", "") or "http://localhost:8000"
|
|
return {
|
|
"name": "MY Network Platform",
|
|
"symbol": "MYN",
|
|
"description": "Decentralized content platform (v3)",
|
|
"image": f"{host}/static/platform.png",
|
|
"external_url": host,
|
|
"version": "3.0.0"
|
|
}
|
|
|
|
|
|
@router.get("/")
|
|
async def index_root():
|
|
return PlainTextResponse("MY Network Node", status_code=200)
|
|
|
|
@router.get("/favicon.ico")
|
|
async def favicon():
|
|
return PlainTextResponse("", status_code=204)
|
|
|
|
|
|
@router.get("/api/v1/node")
|
|
async def v1_node():
|
|
from app.core.crypto import get_ed25519_manager
|
|
cm = get_ed25519_manager()
|
|
return {"id": cm.node_id, "node_address": "", "master_address": "", "indexer_height": 0, "services": {}}
|
|
|
|
@router.get("/api/v1/nodeFriendly")
|
|
async def v1_node_friendly():
|
|
from app.core.crypto import get_ed25519_manager
|
|
cm = get_ed25519_manager()
|
|
return PlainTextResponse(f"Node ID: {cm.node_id}\nIndexer height: 0\nServices: none\n")
|
|
|
|
|
|
@router.post("/api/v1/auth.twa")
|
|
async def v1_auth_twa(payload: dict):
|
|
user_ref = payload.get("user") or {}
|
|
token = base64.b64encode(f"twa:{user_ref}".encode()).decode()
|
|
return {"token": token}
|
|
|
|
@router.get("/api/v1/auth.me")
|
|
async def v1_auth_me():
|
|
return {"user": None, "status": "guest"}
|
|
|
|
@router.post("/api/v1/auth.selectWallet")
|
|
async def v1_auth_select_wallet(payload: dict):
|
|
return {"ok": True}
|
|
|
|
@router.get("/api/v1/tonconnect.new")
|
|
async def v1_tonconnect_new():
|
|
return {"ok": True}
|
|
|
|
@router.post("/api/v1/tonconnect.logout")
|
|
async def v1_tonconnect_logout(payload: dict):
|
|
return {"ok": True}
|
|
|
|
|
|
@router.post("/api/v1/storage")
|
|
async def v1_storage_upload(file: UploadFile = File(...)):
|
|
try:
|
|
data = await file.read()
|
|
if not data:
|
|
raise HTTPException(status_code=400, detail="empty file")
|
|
backend = LocalStorageBackend()
|
|
from hashlib import sha256
|
|
file_hash = sha256(data).hexdigest()
|
|
file_path = os.path.join(backend.files_path, file_hash)
|
|
async with aiofiles.open(file_path, 'wb') as f:
|
|
await f.write(data)
|
|
return {"hash": file_hash}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
await logger.aerror("v1 upload failed", error=str(e))
|
|
raise HTTPException(status_code=500, detail="upload failed")
|
|
|
|
|
|
@router.get("/api/v1/storage/{file_hash}")
|
|
async def v1_storage_get(file_hash: str):
|
|
try:
|
|
async with db_manager.get_session() as session:
|
|
result = await session.execute(text("SELECT file_path FROM my_network_content WHERE hash=:h LIMIT 1"), {"h": file_hash})
|
|
row = result.first()
|
|
if not row or not row[0]:
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
backend = LocalStorageBackend()
|
|
return StreamingResponse(backend.get_file_stream(row[0]))
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
if _is_table_missing_error(e):
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
await logger.aerror("v1 storage get failed", error=str(e))
|
|
raise HTTPException(status_code=500, detail="failed")
|
|
|
|
|
|
@router.get("/api/v1/storage.decodeContentId/{content_id}")
|
|
async def v1_decode_content_id(content_id: str):
|
|
try:
|
|
async with db_manager.get_session() as session:
|
|
result = await session.execute(text("SELECT id, hash, filename, file_size, mime_type FROM my_network_content WHERE id=:i LIMIT 1"), {"i": content_id})
|
|
row = result.first()
|
|
if not row:
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
return {"id": str(row[0]), "hash": row[1], "filename": row[2], "size": row[3], "mime_type": row[4]}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
if _is_table_missing_error(e):
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
await logger.aerror("decodeContentId failed", error=str(e))
|
|
raise HTTPException(status_code=500, detail="failed")
|
|
|
|
|
|
@router.get("/api/v1/content.list")
|
|
async def v1_content_list(limit: int = Query(50, ge=1, le=200), offset: int = Query(0, ge=0)):
|
|
try:
|
|
async with db_manager.get_session() as session:
|
|
result = await session.execute(
|
|
text("SELECT id, hash, filename, file_size, mime_type FROM my_network_content ORDER BY created_at DESC LIMIT :lim OFFSET :off"),
|
|
{"lim": limit, "off": offset}
|
|
)
|
|
rows = result.fetchall() or []
|
|
return {
|
|
"items": [
|
|
{"id": str(r[0]), "hash": r[1], "filename": r[2], "size": r[3], "mime_type": r[4]} for r in rows
|
|
],
|
|
"limit": limit,
|
|
"offset": offset
|
|
}
|
|
except Exception as e:
|
|
if _is_table_missing_error(e):
|
|
return {"items": [], "limit": limit, "offset": offset}
|
|
await logger.aerror("content.list failed", error=str(e))
|
|
raise HTTPException(status_code=500, detail="failed")
|
|
|
|
|
|
@router.get("/api/v1/content.view")
|
|
async def v1_content_view(hash: Optional[str] = None, id: Optional[str] = None):
|
|
try:
|
|
if not hash and not id:
|
|
raise HTTPException(status_code=400, detail="hash or id required")
|
|
async with db_manager.get_session() as session:
|
|
if hash:
|
|
result = await session.execute(text("SELECT id, hash, filename, file_size, mime_type FROM my_network_content WHERE hash=:h LIMIT 1"), {"h": hash})
|
|
else:
|
|
result = await session.execute(text("SELECT id, hash, filename, file_size, mime_type FROM my_network_content WHERE id=:i LIMIT 1"), {"i": id})
|
|
row = result.first()
|
|
if not row:
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
return {"id": str(row[0]), "hash": row[1], "filename": row[2], "size": row[3], "mime_type": row[4], "created_at": None}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
if _is_table_missing_error(e):
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
await logger.aerror("content.view failed", error=str(e))
|
|
raise HTTPException(status_code=500, detail="failed")
|
|
|
|
|
|
@router.get("/api/v1/content.view/{content_address}")
|
|
async def v1_content_view_path(content_address: str):
|
|
try:
|
|
async with db_manager.get_session() as session:
|
|
result = await session.execute(text("SELECT id, hash, filename, file_size, mime_type FROM my_network_content WHERE id=:v OR hash=:v LIMIT 1"), {"v": content_address})
|
|
row = result.first()
|
|
if not row:
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
return {"id": str(row[0]), "hash": row[1], "filename": row[2], "size": row[3], "mime_type": row[4], "created_at": None}
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
if _is_table_missing_error(e):
|
|
raise HTTPException(status_code=404, detail="not found")
|
|
await logger.aerror("content.view(path) failed", error=str(e))
|
|
raise HTTPException(status_code=500, detail="failed")
|
|
|
|
|
|
@router.get("/api/v1/content.friendlyList")
|
|
async def v1_content_friendly_list(limit: int = Query(50, ge=1, le=200), offset: int = Query(0, ge=0)):
|
|
return await v1_content_list(limit, offset)
|
|
|
|
|
|
@router.get("/api/v1.5/content.list")
|
|
async def v1_5_content_list(limit: int = Query(50, ge=1, le=200), offset: int = Query(0, ge=0)):
|
|
return await v1_content_list(limit, offset)
|
|
|
|
|
|
@router.post("/api/v1/blockchain.sendNewContentMessage")
|
|
async def v1_chain_send_new_content(payload: dict):
|
|
await logger.ainfo("compat blockchain.sendNewContentMessage", payload=payload)
|
|
return {"ok": True}
|
|
|
|
|
|
@router.post("/api/v1/blockchain.sendPurchaseContent")
|
|
async def v1_chain_send_purchase(payload: dict):
|
|
await logger.ainfo("compat blockchain.sendPurchaseContent", payload=payload)
|
|
return {"ok": True}
|
|
|
|
|
|
@router.post("/api/v1/blockchain.sendPurchaseContentMessage")
|
|
async def v1_chain_send_purchase_message(payload: dict):
|
|
await logger.ainfo("compat blockchain.sendPurchaseContentMessage", payload=payload)
|
|
return {"ok": True}
|
|
|
|
|
|
@router.get("/api/v1/account")
|
|
async def v1_account():
|
|
return {"ok": True}
|