aws-inventory-manager 0.13.2__py3-none-any.whl

src/web/dependencies.py

@@ -0,0 +1,69 @@
+"""Dependency injection for FastAPI routes."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from ..storage import AuditStore, Database, GroupStore, InventoryStore, ResourceStore, SnapshotStore
+
+# Global instances (initialized at startup)
+_db: Optional[Database] = None
+_storage_path: Optional[str] = None
+
+
+def init_database(storage_path: Optional[str] = None) -> None:
+    """Initialize the database connection.
+
+    Args:
+        storage_path: Optional path to storage directory.
+                     If not provided, uses default from Config.
+    """
+    global _db, _storage_path
+    _storage_path = storage_path
+
+    if storage_path:
+        db_path = Path(storage_path) / "inventory.db"
+        _db = Database(db_path=db_path)
+    else:
+        _db = Database()
+
+    _db.ensure_schema()
+
+
+def get_database() -> Database:
+    """Get the database instance."""
+    global _db
+    if _db is None:
+        init_database(_storage_path)
+    return _db  # type: ignore
+
+
+def get_snapshot_store() -> SnapshotStore:
+    """Get a SnapshotStore instance."""
+    return SnapshotStore(get_database())
+
+
+def get_resource_store() -> ResourceStore:
+    """Get a ResourceStore instance."""
+    return ResourceStore(get_database())
+
+
+def get_inventory_store() -> InventoryStore:
+    """Get an InventoryStore instance."""
+    return InventoryStore(get_database())
+
+
+def get_audit_store() -> AuditStore:
+    """Get an AuditStore instance."""
+    return AuditStore(get_database())
+
+
+def get_group_store() -> GroupStore:
+    """Get a GroupStore instance."""
+    return GroupStore(get_database())
+
+
+def get_storage_path() -> Optional[str]:
+    """Get the configured storage path."""
+    return _storage_path

src/web/routes/__init__.py

@@ -0,0 +1 @@
+"""Web routes package."""

src/web/routes/api/__init__.py

@@ -0,0 +1,18 @@
+"""API routes package."""
+
+from fastapi import APIRouter
+
+from . import charts, cleanup, filters, groups, inventories, queries, resources, snapshots, views
+
+router = APIRouter()
+router.include_router(snapshots.router, tags=["snapshots"])
+router.include_router(resources.router, tags=["resources"])
+router.include_router(queries.router, tags=["queries"])
+router.include_router(charts.router, tags=["charts"])
+router.include_router(cleanup.router, tags=["cleanup"])
+router.include_router(filters.router, tags=["filters"])
+router.include_router(views.router, tags=["views"])
+router.include_router(groups.router, tags=["groups"])
+router.include_router(inventories.router, tags=["inventories"])
+
+__all__ = ["router"]

src/web/routes/api/charts.py

@@ -0,0 +1,156 @@
+"""Chart data API endpoints."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastapi import APIRouter, Query
+
+from ...dependencies import get_resource_store, get_snapshot_store
+
+router = APIRouter(prefix="/charts")
+
+# Chart.js color palette
+CHART_COLORS = [
+    "#3B82F6",  # Blue
+    "#10B981",  # Green
+    "#F59E0B",  # Amber
+    "#EF4444",  # Red
+    "#8B5CF6",  # Purple
+    "#EC4899",  # Pink
+    "#06B6D4",  # Cyan
+    "#84CC16",  # Lime
+    "#F97316",  # Orange
+    "#6366F1",  # Indigo
+]
+
+
+@router.get("/resources-by-type")
+async def chart_resources_by_type(
+    snapshot: Optional[str] = Query(None, description="Limit to specific snapshot"),
+    limit: int = Query(10, le=20),
+):
+    """Get Chart.js data for resources by type."""
+    store = get_resource_store()
+    stats = store.get_stats(snapshot_name=snapshot, group_by="type")[:limit]
+
+    labels = [s["group_key"] for s in stats]
+    data = [s["count"] for s in stats]
+
+    return {
+        "labels": labels,
+        "datasets": [
+            {
+                "data": data,
+                "backgroundColor": CHART_COLORS[:len(data)],
+            }
+        ],
+    }
+
+
+@router.get("/resources-by-region")
+async def chart_resources_by_region(
+    snapshot: Optional[str] = Query(None, description="Limit to specific snapshot"),
+):
+    """Get Chart.js data for resources by region."""
+    store = get_resource_store()
+    stats = store.get_stats(snapshot_name=snapshot, group_by="region")
+
+    labels = [s["group_key"] for s in stats]
+    data = [s["count"] for s in stats]
+
+    return {
+        "labels": labels,
+        "datasets": [
+            {
+                "label": "Resources",
+                "data": data,
+                "backgroundColor": "#3B82F6",
+            }
+        ],
+    }
+
+
+@router.get("/resources-by-service")
+async def chart_resources_by_service(
+    snapshot: Optional[str] = Query(None, description="Limit to specific snapshot"),
+    limit: int = Query(10, le=20),
+):
+    """Get Chart.js data for resources by service."""
+    store = get_resource_store()
+    stats = store.get_stats(snapshot_name=snapshot, group_by="service")[:limit]
+
+    labels = [s["group_key"] for s in stats]
+    data = [s["count"] for s in stats]
+
+    return {
+        "labels": labels,
+        "datasets": [
+            {
+                "data": data,
+                "backgroundColor": CHART_COLORS[:len(data)],
+            }
+        ],
+    }
+
+
+@router.get("/snapshot-trend")
+async def chart_snapshot_trend():
+    """Get Chart.js data for snapshot resource count over time."""
+    store = get_snapshot_store()
+    snapshots = store.list_all()
+
+    # Sort by created_at
+    sorted_snapshots = sorted(snapshots, key=lambda s: s.get("created_at", ""))
+
+    # Take last 10 snapshots for trend
+    recent = sorted_snapshots[-10:] if len(sorted_snapshots) > 10 else sorted_snapshots
+
+    labels = [s["name"][:20] for s in recent]  # Truncate long names
+    data = [s.get("resource_count", 0) for s in recent]
+
+    return {
+        "labels": labels,
+        "datasets": [
+            {
+                "label": "Resource Count",
+                "data": data,
+                "borderColor": "#3B82F6",
+                "backgroundColor": "rgba(59, 130, 246, 0.1)",
+                "fill": True,
+                "tension": 0.3,
+            }
+        ],
+    }
+
+
+@router.get("/tag-coverage")
+async def chart_tag_coverage(
+    snapshot: Optional[str] = Query(None, description="Limit to specific snapshot"),
+):
+    """Get Chart.js data for tag coverage analysis."""
+    resource_store = get_resource_store()
+
+    # Get all resources
+    resources = resource_store.search(snapshot_name=snapshot, limit=10000)
+
+    # Count tagged vs untagged
+    tagged = 0
+    untagged = 0
+
+    for r in resources:
+        tags = r.get("tags", {})
+        if tags and len(tags) > 0:
+            tagged += 1
+        else:
+            untagged += 1
+
+    return {
+        "labels": ["Tagged", "Untagged"],
+        "datasets": [
+            {
+                "data": [tagged, untagged],
+                "backgroundColor": ["#10B981", "#EF4444"],
+            }
+        ],
+    }

src/web/routes/api/cleanup.py

@@ -0,0 +1,186 @@
+"""Cleanup operations API endpoints."""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from ...dependencies import get_audit_store, get_snapshot_store
+
+router = APIRouter(prefix="/cleanup")
+
+
+class CleanupPreviewRequest(BaseModel):
+    """Request for cleanup preview."""
+
+    baseline_snapshot: str
+    resource_types: Optional[List[str]] = None
+    regions: Optional[List[str]] = None
+    protect_tags: Optional[List[str]] = None  # Format: "key=value"
+
+
+class CleanupExecuteRequest(BaseModel):
+    """Request for cleanup execution."""
+
+    baseline_snapshot: str
+    confirmation_token: str  # Must match expected token
+    resource_types: Optional[List[str]] = None
+    regions: Optional[List[str]] = None
+    protect_tags: Optional[List[str]] = None
+
+
+@router.post("/preview")
+async def preview_cleanup(request: CleanupPreviewRequest):
+    """Preview cleanup operation (dry-run).
+
+    Note: This endpoint is a placeholder. Full implementation requires
+    integrating with the ResourceCleaner and collecting current AWS resources.
+    """
+    snapshot_store = get_snapshot_store()
+
+    if not snapshot_store.exists(request.baseline_snapshot):
+        raise HTTPException(status_code=404, detail=f"Snapshot '{request.baseline_snapshot}' not found")
+
+    # TODO: Implement full preview
+    # This would need to:
+    # 1. Load the baseline snapshot
+    # 2. Collect current AWS resources (requires AWS credentials)
+    # 3. Calculate the diff
+    # 4. Apply protection rules
+
+    return {
+        "status": "preview",
+        "message": "Preview endpoint - full implementation pending",
+        "baseline_snapshot": request.baseline_snapshot,
+        "filters": {
+            "resource_types": request.resource_types,
+            "regions": request.regions,
+            "protect_tags": request.protect_tags,
+        },
+        "note": "This preview requires AWS credentials to collect current resources. "
+        "Use the CLI 'awsinv cleanup preview' for full functionality.",
+    }
+
+
+@router.post("/execute")
+async def execute_cleanup(request: CleanupExecuteRequest):
+    """Execute cleanup operation.
+
+    Note: This endpoint is a placeholder. Full implementation requires
+    AWS credentials and careful safety checks.
+    """
+    snapshot_store = get_snapshot_store()
+
+    if not snapshot_store.exists(request.baseline_snapshot):
+        raise HTTPException(status_code=404, detail=f"Snapshot '{request.baseline_snapshot}' not found")
+
+    # For safety, this is not implemented in the web UI
+    # Users should use the CLI for destructive operations
+    raise HTTPException(
+        status_code=501,
+        detail="Cleanup execution is not available in the web UI for safety. "
+        "Please use the CLI: awsinv cleanup execute <snapshot> --confirm",
+    )
+
+
+@router.get("/operations")
+async def list_operations(
+    account_id: Optional[str] = Query(None, description="Filter by account"),
+    limit: int = Query(50, le=200),
+):
+    """List cleanup operations from audit log."""
+    audit_store = get_audit_store()
+    operations = audit_store.list_operations(account_id=account_id, limit=limit)
+
+    return {
+        "count": len(operations),
+        "operations": [
+            {
+                "operation_id": op.operation_id,
+                "baseline_snapshot": op.baseline_snapshot,
+                "timestamp": op.timestamp.isoformat() if hasattr(op.timestamp, "isoformat") else str(op.timestamp),
+                "account_id": op.account_id,
+                "mode": op.mode.value if hasattr(op.mode, "value") else str(op.mode),
+                "status": op.status.value if hasattr(op.status, "value") else str(op.status),
+                "total_resources": op.total_resources,
+                "succeeded_count": op.succeeded_count,
+                "failed_count": op.failed_count,
+                "skipped_count": op.skipped_count,
+                "duration_seconds": op.duration_seconds,
+            }
+            for op in operations
+        ],
+    }
+
+
+@router.get("/operations/{operation_id}")
+async def get_operation(operation_id: str):
+    """Get details of a cleanup operation."""
+    audit_store = get_audit_store()
+    operation = audit_store.load_operation(operation_id)
+
+    if not operation:
+        raise HTTPException(status_code=404, detail="Operation not found")
+
+    return {
+        "operation_id": operation.operation_id,
+        "baseline_snapshot": operation.baseline_snapshot,
+        "timestamp": operation.timestamp.isoformat()
+        if hasattr(operation.timestamp, "isoformat")
+        else str(operation.timestamp),
+        "account_id": operation.account_id,
+        "mode": operation.mode.value if hasattr(operation.mode, "value") else str(operation.mode),
+        "status": operation.status.value if hasattr(operation.status, "value") else str(operation.status),
+        "total_resources": operation.total_resources,
+        "succeeded_count": operation.succeeded_count,
+        "failed_count": operation.failed_count,
+        "skipped_count": operation.skipped_count,
+        "duration_seconds": operation.duration_seconds,
+        "filters": operation.filters,
+    }
+
+
+@router.get("/operations/{operation_id}/records")
+async def get_operation_records(
+    operation_id: str,
+    status: Optional[str] = Query(None, description="Filter by status"),
+    limit: int = Query(100, le=500),
+):
+    """Get deletion records for a cleanup operation."""
+    audit_store = get_audit_store()
+
+    # First verify operation exists
+    operation = audit_store.load_operation(operation_id)
+    if not operation:
+        raise HTTPException(status_code=404, detail="Operation not found")
+
+    records = audit_store.load_records(operation_id)
+
+    # Filter by status if specified
+    if status:
+        records = [r for r in records if str(r.status.value if hasattr(r.status, "value") else r.status) == status]
+
+    # Apply limit
+    records = records[:limit]
+
+    return {
+        "operation_id": operation_id,
+        "count": len(records),
+        "records": [
+            {
+                "record_id": r.record_id,
+                "resource_arn": r.resource_arn,
+                "resource_id": r.resource_id,
+                "resource_type": r.resource_type,
+                "region": r.region,
+                "status": r.status.value if hasattr(r.status, "value") else str(r.status),
+                "error_code": r.error_code,
+                "error_message": r.error_message,
+                "protection_reason": r.protection_reason,
+                "deletion_tier": r.deletion_tier,
+            }
+            for r in records
+        ],
+    }

src/web/routes/api/filters.py

@@ -0,0 +1,253 @@
+"""Saved filters API endpoints."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ...dependencies import get_database
+
+router = APIRouter(prefix="/filters")
+
+
+# Available filter operators
+FILTER_OPERATORS = [
+    {"value": "equals", "label": "equals"},
+    {"value": "not_equals", "label": "does not equal"},
+    {"value": "contains", "label": "contains"},
+    {"value": "not_contains", "label": "does not contain"},
+    {"value": "starts_with", "label": "starts with"},
+    {"value": "not_starts_with", "label": "does not start with"},
+    {"value": "ends_with", "label": "ends with"},
+    {"value": "not_ends_with", "label": "does not end with"},
+    {"value": "is_empty", "label": "is empty"},
+    {"value": "is_not_empty", "label": "is not empty"},
+]
+
+# Available filter fields
+FILTER_FIELDS = [
+    {"value": "name", "label": "Name"},
+    {"value": "arn", "label": "ARN"},
+    {"value": "resource_type", "label": "Type"},
+    {"value": "region", "label": "Region"},
+    {"value": "snapshot_name", "label": "Snapshot"},
+    {"value": "config_hash", "label": "Config Hash"},
+    {"value": "tag_key", "label": "Tag Key"},
+    {"value": "tag_value", "label": "Tag Value"},
+]
+
+
+class FilterCondition(BaseModel):
+    """A single filter condition."""
+
+    field: str
+    operator: str
+    value: Optional[str] = None
+
+
+class FilterConfig(BaseModel):
+    """Filter configuration model - supports both simple and advanced modes."""
+
+    # Simple mode fields (legacy support)
+    resource_type: Optional[str] = None
+    region: Optional[str] = None
+    snapshot: Optional[str] = None
+    search: Optional[str] = None
+    tags: Optional[dict] = None
+
+    # Advanced mode fields
+    logic: Optional[str] = "AND"  # "AND" or "OR"
+    conditions: Optional[List[FilterCondition]] = None
+
+
+class SavedFilter(BaseModel):
+    """Saved filter model."""
+
+    id: Optional[int] = None
+    name: str
+    description: Optional[str] = None
+    filter_config: Any  # Accept both FilterConfig and raw dict
+    is_favorite: bool = False
+
+
+class SavedFilterResponse(BaseModel):
+    """Saved filter response model."""
+
+    id: int
+    name: str
+    description: Optional[str]
+    filter_config: dict
+    is_favorite: bool
+    created_at: str
+    last_used_at: Optional[str]
+    use_count: int
+
+
+@router.get("/schema")
+async def get_filter_schema():
+    """Get available filter fields and operators."""
+    return {
+        "fields": FILTER_FIELDS,
+        "operators": FILTER_OPERATORS,
+        "logic_options": ["AND", "OR"],
+    }
+
+
+@router.get("")
+async def list_saved_filters(favorites_only: bool = False):
+    """List saved filters."""
+    db = get_database()
+
+    sql = "SELECT * FROM saved_filters WHERE 1=1"
+    params: List = []
+
+    if favorites_only:
+        sql += " AND is_favorite = 1"
+
+    sql += " ORDER BY is_favorite DESC, last_used_at DESC NULLS LAST, name"
+
+    rows = db.fetchall(sql, tuple(params))
+
+    filters = []
+    for row in rows:
+        row_dict = dict(row)
+        # Parse the JSON filter_config
+        if row_dict.get("filter_config"):
+            row_dict["filter_config"] = json.loads(row_dict["filter_config"])
+        filters.append(row_dict)
+
+    return {"filters": filters}
+
+
+@router.post("")
+async def create_saved_filter(filter_data: SavedFilter):
+    """Save a new filter."""
+    db = get_database()
+
+    try:
+        # Handle both Pydantic model and raw dict
+        if hasattr(filter_data.filter_config, "model_dump"):
+            config_json = json.dumps(filter_data.filter_config.model_dump())
+        else:
+            config_json = json.dumps(filter_data.filter_config)
+
+        cursor = db.execute(
+            """
+            INSERT INTO saved_filters (name, description, filter_config, is_favorite, created_at)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (
+                filter_data.name,
+                filter_data.description,
+                config_json,
+                filter_data.is_favorite,
+                datetime.utcnow().isoformat(),
+            ),
+        )
+        db._conn.commit()  # type: ignore
+        return {"id": cursor.lastrowid, "message": "Filter saved"}
+    except Exception as e:
+        if "UNIQUE constraint" in str(e):
+            raise HTTPException(
+                status_code=400, detail=f"Filter with name '{filter_data.name}' already exists"
+            )
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{filter_id}")
+async def get_saved_filter(filter_id: int):
+    """Get a saved filter by ID."""
+    db = get_database()
+    row = db.fetchone("SELECT * FROM saved_filters WHERE id = ?", (filter_id,))
+
+    if not row:
+        raise HTTPException(status_code=404, detail="Filter not found")
+
+    row_dict = dict(row)
+    if row_dict.get("filter_config"):
+        row_dict["filter_config"] = json.loads(row_dict["filter_config"])
+    return row_dict
+
+
+@router.put("/{filter_id}")
+async def update_saved_filter(filter_id: int, filter_data: SavedFilter):
+    """Update a saved filter."""
+    db = get_database()
+
+    existing = db.fetchone("SELECT id FROM saved_filters WHERE id = ?", (filter_id,))
+    if not existing:
+        raise HTTPException(status_code=404, detail="Filter not found")
+
+    # Handle both Pydantic model and raw dict
+    if hasattr(filter_data.filter_config, "model_dump"):
+        config_json = json.dumps(filter_data.filter_config.model_dump())
+    else:
+        config_json = json.dumps(filter_data.filter_config)
+
+    db.execute(
+        """
+        UPDATE saved_filters
+        SET name = ?, description = ?, filter_config = ?, is_favorite = ?
+        WHERE id = ?
+        """,
+        (filter_data.name, filter_data.description, config_json, filter_data.is_favorite, filter_id),
+    )
+    db._conn.commit()  # type: ignore
+    return {"message": "Filter updated"}
+
+
+@router.delete("/{filter_id}")
+async def delete_saved_filter(filter_id: int):
+    """Delete a saved filter."""
+    db = get_database()
+
+    existing = db.fetchone("SELECT id FROM saved_filters WHERE id = ?", (filter_id,))
+    if not existing:
+        raise HTTPException(status_code=404, detail="Filter not found")
+
+    db.execute("DELETE FROM saved_filters WHERE id = ?", (filter_id,))
+    db._conn.commit()  # type: ignore
+    return {"message": "Filter deleted"}
+
+
+@router.post("/{filter_id}/use")
+async def mark_filter_used(filter_id: int):
+    """Mark a filter as used (updates last_used_at and use_count)."""
+    db = get_database()
+
+    existing = db.fetchone("SELECT id FROM saved_filters WHERE id = ?", (filter_id,))
+    if not existing:
+        raise HTTPException(status_code=404, detail="Filter not found")
+
+    db.execute(
+        """
+        UPDATE saved_filters
+        SET last_used_at = ?, use_count = use_count + 1
+        WHERE id = ?
+        """,
+        (datetime.utcnow().isoformat(), filter_id),
+    )
+    db._conn.commit()  # type: ignore
+    return {"message": "Filter marked as used"}
+
+
+@router.post("/{filter_id}/favorite")
+async def toggle_filter_favorite(filter_id: int):
+    """Toggle the favorite status of a filter."""
+    db = get_database()
+
+    existing = db.fetchone("SELECT id, is_favorite FROM saved_filters WHERE id = ?", (filter_id,))
+    if not existing:
+        raise HTTPException(status_code=404, detail="Filter not found")
+
+    new_favorite = not existing["is_favorite"]
+    db.execute(
+        "UPDATE saved_filters SET is_favorite = ? WHERE id = ?",
+        (new_favorite, filter_id),
+    )
+    db._conn.commit()  # type: ignore
+    return {"message": "Favorite toggled", "is_favorite": new_favorite}