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

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}