update app/routers/proxies.py

app/routers/proxies.py

@@ -0,0 +1,465 @@
+from fastapi import APIRouter, Depends, Query, HTTPException, Request, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List, Optional
+from pydantic import BaseModel
+from datetime import datetime
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+import aiohttp
+import asyncio
+import time
+
+from app.database import get_db
+from app.db_storage import db_storage
+from app.dependencies import require_admin
+
+# Rate limiter for this router
+limiter = Limiter(key_func=get_remote_address)
+
+router = APIRouter(prefix="/api/v1", tags=["proxies"])
+
+
+class ProxyResponse(BaseModel):
+    id: int
+    url: str
+    protocol: str
+    ip: Optional[str]
+    port: Optional[int]
+    country_code: Optional[str]
+    country_name: Optional[str]
+    state: Optional[str]
+    city: Optional[str]
+    latency_ms: Optional[int]
+    speed_mbps: Optional[float]
+    anonymity: Optional[str]
+    proxy_type: Optional[str]
+    can_access_google: Optional[bool]
+    quality_score: Optional[int]
+    is_working: bool
+    last_validated: Optional[str]
+
+    class Config:
+        from_attributes = True
+
+
+class ProxiesListResponse(BaseModel):
+    total: int
+    count: int
+    offset: int
+    limit: int
+    proxies: List[ProxyResponse]
+
+
+@router.get("/proxies/advanced", response_model=ProxiesListResponse)
+async def get_proxies_advanced(
+    protocol: Optional[str] = Query(None, description="Filter by protocol"),
+    country_code: Optional[str] = Query(
+        None, description="Filter by country code (e.g., US, GB)"
+    ),
+    anonymity: Optional[str] = Query(
+        None, description="Filter by anonymity level (transparent, anonymous, elite)"
+    ),
+    proxy_type: Optional[str] = Query(
+        None, description="Filter by type (datacenter, residential, mobile)"
+    ),
+    can_access_google: Optional[bool] = Query(
+        None, description="Filter by Google accessibility"
+    ),
+    min_quality: Optional[int] = Query(
+        None, ge=0, le=100, description="Minimum quality score (0-100)"
+    ),
+    min_speed: Optional[float] = Query(None, ge=0, description="Minimum speed in Mbps"),
+    max_latency: Optional[int] = Query(None, ge=0, description="Maximum latency in ms"),
+    is_working: bool = Query(True, description="Show only working proxies"),
+    order_by: str = Query(
+        "quality_score",
+        description="Sort by: quality_score, latency_ms, speed_mbps, created_at",
+    ),
+    order_direction: str = Query("desc", description="Sort direction: asc or desc"),
+    limit: int = Query(100, ge=1, le=1000, description="Number of results"),
+    offset: int = Query(0, ge=0, description="Offset for pagination"),
+    session: AsyncSession = Depends(get_db),
+):
+    proxies, total = await db_storage.get_proxies(
+        session=session,
+        protocol=protocol,
+        country_code=country_code,
+        anonymity=anonymity,
+        min_quality=min_quality,
+        is_working=is_working,
+        limit=limit,
+        offset=offset,
+        order_by=order_by,
+    )
+
+    filtered_proxies = []
+    for proxy in proxies:
+        if proxy_type and proxy.proxy_type != proxy_type:
+            continue
+        if (
+            can_access_google is not None
+            and proxy.can_access_google != can_access_google
+        ):
+            continue
+        if min_speed is not None and (
+            proxy.speed_mbps is None or proxy.speed_mbps < min_speed
+        ):
+            continue
+        if max_latency is not None and (
+            proxy.latency_ms is None or proxy.latency_ms > max_latency
+        ):
+            continue
+
+        filtered_proxies.append(proxy)
+
+    return ProxiesListResponse(
+        total=total,
+        count=len(filtered_proxies),
+        offset=offset,
+        limit=limit,
+        proxies=[
+            ProxyResponse(
+                **{
+                    **proxy.__dict__,
+                    "last_validated": proxy.last_validated.isoformat()
+                    if proxy.last_validated
+                    else None,
+                }
+            )
+            for proxy in filtered_proxies
+        ],
+    )
+
+
+@router.get("/proxies/filters/options")
+async def get_filter_options(session: AsyncSession = Depends(get_db)):
+    from sqlalchemy import select, func, distinct
+    from app.db_models import Proxy
+
+    protocols_result = await session.execute(
+        select(distinct(Proxy.protocol)).where(Proxy.is_working == True)
+    )
+    protocols = [p for p in protocols_result.scalars().all() if p]
+
+    countries_result = await session.execute(
+        select(
+            Proxy.country_code, Proxy.country_name, func.count(Proxy.id).label("count")
+        )
+        .where(Proxy.is_working == True, Proxy.country_code.isnot(None))
+        .group_by(Proxy.country_code, Proxy.country_name)
+        .order_by(func.count(Proxy.id).desc())
+        .limit(50)
+    )
+    countries = [
+        {"code": row.country_code, "name": row.country_name, "count": row.count}
+        for row in countries_result.all()
+    ]
+
+    anonymity_levels = ["transparent", "anonymous", "elite"]
+    proxy_types = ["datacenter", "residential", "mobile", "unknown"]
+
+    quality_ranges = [
+        {"label": "Excellent (80-100)", "min": 80, "max": 100},
+        {"label": "Good (60-79)", "min": 60, "max": 79},
+        {"label": "Fair (40-59)", "min": 40, "max": 59},
+        {"label": "Poor (0-39)", "min": 0, "max": 39},
+    ]
+
+    return {
+        "protocols": protocols,
+        "countries": countries,
+        "anonymity_levels": anonymity_levels,
+        "proxy_types": proxy_types,
+        "quality_ranges": quality_ranges,
+        "sort_options": [
+            {"value": "quality_score", "label": "Quality Score"},
+            {"value": "latency_ms", "label": "Latency (fastest first)"},
+            {"value": "speed_mbps", "label": "Speed (fastest first)"},
+            {"value": "created_at", "label": "Recently Added"},
+        ],
+    }
+
+
+@router.get("/proxies/export")
+@limiter.limit("100/hour")  # Rate limit: 100 exports per hour
+async def export_proxies(
+    request: Request,
+    format: str = Query("txt", description="Export format: txt, json, csv, pac"),
+    protocol: Optional[str] = None,
+    country_code: Optional[str] = None,
+    min_quality: Optional[int] = None,
+    limit: int = Query(1000, ge=1, le=10000),
+    session: AsyncSession = Depends(get_db),
+):
+    from fastapi.responses import PlainTextResponse, StreamingResponse
+    import json
+    import io
+
+    proxies, _ = await db_storage.get_proxies(
+        session=session,
+        protocol=protocol,
+        country_code=country_code,
+        min_quality=min_quality,
+        is_working=True,
+        limit=limit,
+        offset=0,
+        order_by="quality_score",
+    )
+
+    if format == "txt":
+        content = "\n".join([proxy.url for proxy in proxies])
+        return PlainTextResponse(content=content, media_type="text/plain")
+
+    elif format == "json":
+        data = [
+            {
+                "url": proxy.url,
+                "protocol": proxy.protocol,
+                "country": proxy.country_code,
+                "latency_ms": proxy.latency_ms,
+                "anonymity": proxy.anonymity,
+                "quality_score": proxy.quality_score,
+            }
+            for proxy in proxies
+        ]
+        return PlainTextResponse(
+            content=json.dumps(data, indent=2), media_type="application/json"
+        )
+
+    elif format == "csv":
+        import csv
+
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(
+            ["URL", "Protocol", "Country", "Latency(ms)", "Anonymity", "Quality"]
+        )
+
+        for proxy in proxies:
+            writer.writerow(
+                [
+                    proxy.url,
+                    proxy.protocol,
+                    proxy.country_code or "",
+                    proxy.latency_ms or "",
+                    proxy.anonymity or "",
+                    proxy.quality_score or "",
+                ]
+            )
+
+        return StreamingResponse(
+            iter([output.getvalue()]),
+            media_type="text/csv",
+            headers={"Content-Disposition": "attachment; filename=proxies.csv"},
+        )
+
+    elif format == "pac":
+        # Generate PAC (Proxy Auto-Config) file for browser configuration
+        # Filter to HTTP/HTTPS proxies only (PAC doesn't support other protocols)
+        http_proxies = [p for p in proxies if p.protocol.lower() in ["http", "https"]]
+
+        if not http_proxies:
+            proxy_list = "DIRECT"
+        else:
+            # Build proxy list (round-robin load balancing)
+            proxy_list = "; ".join(
+                [
+                    f"PROXY {p.ip}:{p.port}"
+                    for p in http_proxies[:10]  # Limit to top 10 for performance
+                ]
+            )
+            proxy_list += "; DIRECT"
+
+        pac_content = f"""function FindProxyForURL(url, host) {{
+    // 1proxy PAC File - Auto-generated proxy configuration
+    // Generated: {datetime.utcnow().isoformat()}
+    // Total proxies: {len(http_proxies)}
+    
+    // Bypass localhost and private networks
+    if (isPlainHostName(host) ||
+        shExpMatch(host, "*.local") ||
+        isInNet(host, "10.0.0.0", "255.0.0.0") ||
+        isInNet(host, "172.16.0.0", "255.240.0.0") ||
+        isInNet(host, "192.168.0.0", "255.255.0.0") ||
+        isInNet(host, "127.0.0.0", "255.0.0.0")) {{
+        return "DIRECT";
+    }}
+    
+    // Use proxy for all other requests (round-robin)
+    return "{proxy_list}";
+}}"""
+
+        return PlainTextResponse(
+            content=pac_content,
+            media_type="application/x-ns-proxy-autoconfig",
+            headers={"Content-Disposition": "attachment; filename=1proxy.pac"},
+        )
+
+    return {"error": "Invalid format. Supported: txt, json, csv, pac"}
+
+
+@router.get("/proxies/random", response_model=ProxyResponse)
+async def get_random_proxy(
+    protocol: Optional[str] = Query(None, description="Filter by protocol"),
+    country_code: Optional[str] = Query(None, description="Filter by country code"),
+    min_quality: Optional[int] = Query(None, description="Minimum quality score"),
+    anonymity: Optional[str] = Query(
+        None, description="Filter by anonymity (transparent, anonymous, elite)"
+    ),
+    max_latency: Optional[int] = Query(None, description="Maximum latency in ms"),
+    exclude: Optional[str] = Query(
+        None,
+        description="Comma-separated list of IPs to exclude (e.g., '1.2.3.4,5.6.7.8')",
+    ),
+    session: AsyncSession = Depends(get_db),
+):
+    """
+    Get a random high-quality proxy with smart filtering.
+
+    Use the 'exclude' parameter to implement rotation by excluding
+    previously used IPs. This ensures you get different proxies
+    on each request.
+
+    Example: /proxies/random?min_quality=70&exclude=192.168.1.1,10.0.0.1
+    """
+
+    # Parse exclude list
+    excluded_ips = set()
+    if exclude:
+        excluded_ips = set(ip.strip() for ip in exclude.split(",") if ip.strip())
+
+    proxy = await db_storage.get_random_proxy(
+        session=session,
+        protocol=protocol,
+        country_code=country_code,
+        min_quality=min_quality,
+        anonymity=anonymity,
+        max_latency=max_latency,
+    )
+
+    # If proxy is in exclude list, try to get another one
+    max_attempts = 5
+    attempts = 0
+    while proxy and proxy.ip in excluded_ips and attempts < max_attempts:
+        proxy = await db_storage.get_random_proxy(
+            session=session,
+            protocol=protocol,
+            country_code=country_code,
+            min_quality=min_quality,
+            anonymity=anonymity,
+            max_latency=max_latency,
+        )
+        attempts += 1
+
+    if not proxy:
+        raise HTTPException(status_code=404, detail="No matching proxies found")
+
+    if proxy.ip in excluded_ips:
+        raise HTTPException(
+            status_code=404,
+            detail="No proxies available that are not in the exclude list",
+        )
+
+    return ProxyResponse(
+        **{
+            **proxy.__dict__,
+            "last_validated": proxy.last_validated.isoformat()
+            if proxy.last_validated
+            else None,
+        }
+    )
+
+
+class ProxyTestRequest(BaseModel):
+    proxy_url: str
+    target_url: str = "https://www.google.com"
+    timeout: int = 5
+
+
+class ProxyTestResponse(BaseModel):
+    proxy_url: str
+    target_url: str
+    working: bool
+    latency_ms: Optional[int]
+    status_code: Optional[int]
+    error: Optional[str]
+    tested_at: str
+
+
+@router.post("/proxies/test", response_model=ProxyTestResponse)
+@limiter.limit("10/minute")  # Rate limit: 10 tests per minute to prevent abuse
+async def test_proxy(request: Request, test_request: ProxyTestRequest):
+    """
+    Test if a proxy works by making a request through it.
+
+    This endpoint is rate-limited to prevent abuse.
+    Free tier: 10 tests per minute.
+    """
+    tested_at = datetime.utcnow().isoformat()
+
+    try:
+        # Parse proxy URL
+        if not test_request.proxy_url.startswith(("http://", "https://", "socks5://")):
+            raise HTTPException(
+                status_code=400,
+                detail="Invalid proxy URL. Must start with http://, https://, or socks5://",
+            )
+
+        start_time = time.time()
+
+        # Create aiohttp session with proxy
+        timeout_config = aiohttp.ClientTimeout(total=test_request.timeout)
+
+        async with aiohttp.ClientSession(timeout=timeout_config) as session:
+            try:
+                async with session.get(
+                    test_request.target_url,
+                    proxy=test_request.proxy_url,
+                    ssl=False,  # Skip SSL verification for testing
+                ) as response:
+                    latency_ms = int((time.time() - start_time) * 1000)
+
+                    return ProxyTestResponse(
+                        proxy_url=test_request.proxy_url,
+                        target_url=test_request.target_url,
+                        working=True,
+                        latency_ms=latency_ms,
+                        status_code=response.status,
+                        error=None,
+                        tested_at=tested_at,
+                    )
+            except aiohttp.ClientError as e:
+                return ProxyTestResponse(
+                    proxy_url=test_request.proxy_url,
+                    target_url=test_request.target_url,
+                    working=False,
+                    latency_ms=None,
+                    status_code=None,
+                    error=f"Connection error: {str(e)}",
+                    tested_at=tested_at,
+                )
+
+    except asyncio.TimeoutError:
+        return ProxyTestResponse(
+            proxy_url=test_request.proxy_url,
+            target_url=test_request.target_url,
+            working=False,
+            latency_ms=None,
+            status_code=None,
+            error="Connection timeout",
+            tested_at=tested_at,
+        )
+
+
+@router.delete("/proxies/{proxy_id}", status_code=status.HTTP_204_NO_CONTENT)
+@limiter.limit("30/minute")
+async def delete_proxy(
+    request: Request,
+    proxy_id: int,
+    session: AsyncSession = Depends(get_db),
+    admin_user=Depends(require_admin),
+):
+    success = await db_storage.delete_proxy(session, proxy_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Proxy not found")
+    return None