digbee_list_projects.py

from fastapi import FastAPI, Request, HTTPException
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
import requests
from typing import List, Optional
from pydantic import BaseModel
import logging
from math import radians, sin, cos, sqrt, atan2
from fastapi.middleware.cors import CORSMiddleware

# Initialize FastAPI app
app = FastAPI()

# Configure CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Mount static files - ensure this is before any routes
app.mount("/static", StaticFiles(directory="static"), name="static")

# Initialize templates
templates = Jinja2Templates(directory="templates")

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Pydantic models
class GeoPoint(BaseModel):
    lat: float
    lng: float

class Company(BaseModel):
    id: int
    name: str

class MiningProject(BaseModel):
    id: Optional[int]
    name: Optional[str]
    status: Optional[str]
    mineType: Optional[str]
    companies: Optional[List[Company]] = []
    companiesString: Optional[str]
    country: Optional[str]
    depositType: Optional[str]
    geoPoint: Optional[GeoPoint]
    region: Optional[str]
    commodity: Optional[str]
    grade: Optional[str]
    contained: Optional[str]
    lifeOfMine: Optional[str]
    dataSource: Optional[str]

@app.get("/")
async def home(request: Request):
    """Render the main projects table page"""
    return templates.TemplateResponse("index.html", {"request": request})

@app.get("/analytics")
async def analytics_page(request: Request):
    """Render the analytics page"""
    return templates.TemplateResponse("analytics.html", {"request": request})

@app.get("/project/{project_id}")
async def project_details(request: Request, project_id: int):
    """Render the project details page"""
    return templates.TemplateResponse("project_dashboard.html", {
        "request": request,
        "project_id": project_id
    })

@app.get("/api/mining-data")
async def get_mining_data():
    """Get all mining project data"""
    try:
        url = "https://digbee.com/api/v2/search/projects"
        headers = {
            'User-Agent': 'Mozilla/5.0',
            'Accept': 'application/json'
        }
        
        logger.info(f"Fetching data from {url}")
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        
        data = response.json()
        logger.info(f"Successfully retrieved {len(data)} projects")
        
        # Convert raw data to MiningProject objects for validation
        mining_projects = [MiningProject(**project).dict() for project in data]
        return mining_projects
        
    except requests.RequestException as e:
        logger.error(f"API request failed: {str(e)}")
        raise HTTPException(status_code=503, detail=f"Failed to fetch data: {str(e)}")
    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")

@app.get("/api/nearby-projects/{project_id}")
async def get_nearby_projects(project_id: int):
    """Get projects within 500km radius of the specified project"""
    try:
        all_projects = await get_mining_data()
        target_project = next((p for p in all_projects if p["id"] == project_id), None)
        
        if not target_project or not target_project.get("geoPoint"):
            return []
            
        nearby = []
        for project in all_projects:
            if project["id"] != project_id and project.get("geoPoint"):
                distance = calculate_distance(
                    target_project["geoPoint"],
                    project["geoPoint"]
                )
                if distance <= 500:  # 500km radius
                    project_dict = project.copy()
                    project_dict["distance"] = round(distance, 2)
                    nearby.append(project_dict)
                    
        return nearby
    except Exception as e:
        logger.error(f"Error finding nearby projects: {str(e)}")
        raise HTTPException(status_code=500, detail="Error processing nearby projects")

def calculate_distance(point1: dict, point2: dict) -> float:
    """Calculate distance between two points using Haversine formula"""
    R = 6371  # Earth's radius in kilometers

    lat1 = radians(point1["lat"])
    lon1 = radians(point1["lng"])
    lat2 = radians(point2["lat"])
    lon2 = radians(point2["lng"])

    dlat = lat2 - lat1
    dlon = lon2 - lon1

    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * atan2(sqrt(a), sqrt(1-a))
    distance = R * c

    return distance

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)