313 lines
10 KiB
Python
313 lines
10 KiB
Python
from fastapi import APIRouter, HTTPException, Header, Response
|
|
from typing import Optional, List, Literal, Union, Annotated
|
|
from urllib.parse import unquote
|
|
from app.config import API_KEY
|
|
from app.database import get_cached_data, save_to_cache
|
|
from pydantic import BaseModel, Field
|
|
from app.services.browser import (
|
|
visit_url_service,
|
|
screenshot_url_service,
|
|
interactions_service,
|
|
extract_seo_service,
|
|
extract_meta_tags_service,
|
|
capture_outgoing_calls_service,
|
|
get_resulting_url_service
|
|
)
|
|
|
|
router = APIRouter(tags=["Browser"])
|
|
|
|
class ClickInteraction(BaseModel):
|
|
action: Literal["click"]
|
|
selector: Optional[str] = None
|
|
xpath_selector: Optional[str] = None
|
|
x: Optional[int] = None
|
|
y: Optional[int] = None
|
|
|
|
|
|
class TypeInteraction(BaseModel):
|
|
action: Literal["type"]
|
|
selector: Optional[str] = None
|
|
xpath_selector: Optional[str] = None
|
|
text: str
|
|
x: Optional[int] = None
|
|
y: Optional[int] = None
|
|
|
|
|
|
Interaction = Annotated[
|
|
Union[ClickInteraction, TypeInteraction],
|
|
Field(discriminator="action"),
|
|
]
|
|
|
|
|
|
class Viewport(BaseModel):
|
|
width: int
|
|
height: int
|
|
|
|
|
|
class InteractionsRequest(BaseModel):
|
|
url: str = Field(..., description="Target URL (will be URL-decoded server-side).")
|
|
returnType: Optional[Literal["screenshot", "html", "resulting_url"]] = Field(
|
|
"screenshot",
|
|
description="Return a PNG screenshot, HTML content, or the resulting URL after interactions.",
|
|
)
|
|
viewport: Optional[Viewport] = None
|
|
scrollX: Optional[int] = None
|
|
scrollY: Optional[int] = None
|
|
interactions: List[Interaction]
|
|
|
|
@router.get(
|
|
"/",
|
|
summary="Visit URL",
|
|
description="Navigate to `url` and return HTML content (cached unless `skipCache=true`).",
|
|
)
|
|
async def visit_url(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
|
|
# Validate API key
|
|
if not x_api_key or x_api_key != API_KEY:
|
|
raise HTTPException(status_code=401, detail="Invalid API key")
|
|
|
|
# Decode URL if it's encoded
|
|
decoded_url = unquote(url)
|
|
|
|
# Check cache first (unless skipCache is True)
|
|
if not skipCache:
|
|
cached_result = get_cached_data(decoded_url, "visit")
|
|
if cached_result:
|
|
return cached_result
|
|
|
|
try:
|
|
# Call the service function
|
|
result = await visit_url_service(decoded_url)
|
|
|
|
if(result["status"] == "success"):
|
|
# Save to cache (even if we skipped reading from it)
|
|
save_to_cache(decoded_url, "visit", result)
|
|
|
|
return result
|
|
except Exception as e:
|
|
print(f"Error visiting URL {decoded_url}: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.get(
|
|
"/screenshot",
|
|
summary="Capture screenshot",
|
|
description="Capture a PNG screenshot for `url`.",
|
|
responses={
|
|
200: {"content": {"image/png": {}}},
|
|
401: {"description": "Invalid API key"},
|
|
500: {"description": "Screenshot capture failed"},
|
|
},
|
|
)
|
|
async def screenshot_url(url: str, fullPage: bool = True, x_api_key: Optional[str] = Header(None)):
|
|
"""Capture a screenshot of a website and return it as PNG"""
|
|
if not x_api_key or x_api_key != API_KEY:
|
|
raise HTTPException(status_code=401, detail="Invalid API key")
|
|
|
|
decoded_url = unquote(url)
|
|
|
|
try:
|
|
result = await screenshot_url_service(decoded_url, fullPage)
|
|
|
|
if isinstance(result, dict) and result.get("status") == "error":
|
|
raise HTTPException(status_code=500, detail=result.get("error", "Screenshot capture failed"))
|
|
|
|
if not isinstance(result, (bytes, bytearray)):
|
|
raise HTTPException(status_code=500, detail="Unexpected screenshot response")
|
|
|
|
return Response(content=result, media_type="image/png")
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
print(f"Error taking screenshot for URL {decoded_url}: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.post(
|
|
"/interactions",
|
|
summary="Run interactions",
|
|
description=(
|
|
"Run a sequence of interactions (click/type) on a page.\n\n"
|
|
"- `returnType=screenshot` returns `image/png`\n"
|
|
"- `returnType=html` returns `text/html`\n"
|
|
"- `returnType=resulting_url` returns `application/json` with the final URL"
|
|
),
|
|
responses={
|
|
200: {
|
|
"content": {
|
|
"image/png": {},
|
|
"text/html": {},
|
|
"application/json": {},
|
|
}
|
|
},
|
|
401: {"description": "Invalid API key"},
|
|
500: {"description": "Interaction failed"},
|
|
},
|
|
)
|
|
async def run_interactions(payload: InteractionsRequest, x_api_key: Optional[str] = Header(None)):
|
|
if not x_api_key or x_api_key != API_KEY:
|
|
raise HTTPException(status_code=401, detail="Invalid API key")
|
|
|
|
decoded_url = unquote(payload.url)
|
|
return_type = (payload.returnType or "screenshot").lower()
|
|
|
|
try:
|
|
result = await interactions_service(
|
|
decoded_url,
|
|
payload.interactions,
|
|
return_type,
|
|
viewport=payload.viewport,
|
|
scroll_x=payload.scrollX,
|
|
scroll_y=payload.scrollY,
|
|
)
|
|
|
|
if isinstance(result, dict) and result.get("status") == "error":
|
|
raise HTTPException(status_code=500, detail=result.get("error", "Interaction failed"))
|
|
|
|
if return_type == "resulting_url":
|
|
if not isinstance(result, dict):
|
|
raise HTTPException(status_code=500, detail="Unexpected resulting_url response")
|
|
return result
|
|
|
|
if return_type == "html":
|
|
if not isinstance(result, str):
|
|
raise HTTPException(status_code=500, detail="Unexpected HTML response")
|
|
return Response(content=result, media_type="text/html; charset=utf-8")
|
|
|
|
if not isinstance(result, (bytes, bytearray)):
|
|
raise HTTPException(status_code=500, detail="Unexpected screenshot response")
|
|
return Response(content=result, media_type="image/png")
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
print(f"Error running interactions on URL {decoded_url}: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.get(
|
|
"/seo",
|
|
summary="Extract SEO information",
|
|
description="Extract SEO information from `url` (cached unless `skipCache=true`).",
|
|
)
|
|
async def extract_seo(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
|
|
"""Extract SEO information from a website"""
|
|
# Validate API key
|
|
if not x_api_key or x_api_key != API_KEY:
|
|
raise HTTPException(status_code=401, detail="Invalid API key")
|
|
|
|
# Decode URL if it's encoded
|
|
decoded_url = unquote(url)
|
|
|
|
# Check cache first (unless skipCache is True)
|
|
if not skipCache:
|
|
cached_result = get_cached_data(decoded_url, "seo")
|
|
if cached_result:
|
|
return cached_result
|
|
|
|
try:
|
|
# Call the service function
|
|
result = await extract_seo_service(decoded_url)
|
|
|
|
# Save to cache
|
|
if(result["status"] == "success"):
|
|
save_to_cache(decoded_url, "seo", result)
|
|
|
|
return result
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
@router.get(
|
|
"/meta",
|
|
summary="Extract meta tags",
|
|
description="Extract meta tags / Open Graph / Twitter card data from `url` (cached unless `skipCache=true`).",
|
|
)
|
|
async def extract_meta_tags(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
|
|
"""Extract meta tags from a website"""
|
|
# Validate API key
|
|
if not x_api_key or x_api_key != API_KEY:
|
|
raise HTTPException(status_code=401, detail="Invalid API key")
|
|
|
|
# Decode URL if it's encoded
|
|
decoded_url = unquote(url)
|
|
|
|
# Check cache first (unless skipCache is True)
|
|
if not skipCache:
|
|
cached_result = get_cached_data(decoded_url, "meta")
|
|
if cached_result:
|
|
return cached_result
|
|
|
|
try:
|
|
# Call the service function
|
|
result = await extract_meta_tags_service(decoded_url)
|
|
|
|
# Save to cache
|
|
if(result["status"] == "success"):
|
|
save_to_cache(decoded_url, "meta", result)
|
|
|
|
return result
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
@router.get(
|
|
"/outgoing-calls",
|
|
summary="Capture outgoing calls",
|
|
description="Capture outgoing API calls from `url` (cached unless `skipCache=true`).",
|
|
)
|
|
async def capture_outgoing_calls(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
|
|
"""Capture outgoing API calls from a website"""
|
|
# Validate API key
|
|
if not x_api_key or x_api_key != API_KEY:
|
|
raise HTTPException(status_code=401, detail="Invalid API key")
|
|
|
|
# Decode URL if it's encoded
|
|
decoded_url = unquote(url)
|
|
|
|
# Check cache first (unless skipCache is True)
|
|
if not skipCache:
|
|
cached_result = get_cached_data(decoded_url, "outgoing_calls")
|
|
if cached_result:
|
|
return cached_result
|
|
|
|
try:
|
|
# Call the service function
|
|
result = await capture_outgoing_calls_service(decoded_url)
|
|
|
|
# Save to cache
|
|
if(result["status"] == "success"):
|
|
save_to_cache(decoded_url, "outgoing_calls", result)
|
|
|
|
return result
|
|
except Exception as e:
|
|
print(f"Error capturing outgoing calls for URL {decoded_url}: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
@router.get(
|
|
"/resulting-url",
|
|
summary="Get resulting URL",
|
|
description="Get the final URL after navigation/redirects for `url` (cached unless `skipCache=true`).",
|
|
)
|
|
async def get_resulting_url(url: str, skipCache: bool = False, x_api_key: Optional[str] = Header(None)):
|
|
"""Get the resulting URL after navigation (handles redirects)"""
|
|
# Validate API key
|
|
if not x_api_key or x_api_key != API_KEY:
|
|
raise HTTPException(status_code=401, detail="Invalid API key")
|
|
|
|
# Decode URL if it's encoded
|
|
decoded_url = unquote(url)
|
|
|
|
# Check cache first (unless skipCache is True)
|
|
if not skipCache:
|
|
cached_result = get_cached_data(decoded_url, "resulting_url")
|
|
if cached_result:
|
|
return cached_result
|
|
|
|
try:
|
|
# Call the service function
|
|
result = await get_resulting_url_service(decoded_url)
|
|
|
|
# Save to cache
|
|
if(result["status"] == "success"):
|
|
save_to_cache(decoded_url, "resulting_url", result)
|
|
|
|
return result
|
|
except Exception as e:
|
|
print(f"Error getting resulting URL for {decoded_url}: {e}")
|
|
raise HTTPException(status_code=500, detail=str(e)) |