Revert "v0.2.2b1 (#602)" (#603)

This reverts commit 3dd1ffb.

Author: maziggy

CHANGELOG.md

@@ -191,7 +191,6 @@ Perfect for remote print farms, traveling makers, or accessing your home printer
 - Debug logging toggle with live indicator
 - Live application log viewer with filtering
 - Support bundle generator with comprehensive diagnostics (privacy-filtered)
-- **In-app bug reporting** — Submit bug reports directly from the UI with optional screenshot (upload, paste, or drag & drop), automatic diagnostic log collection (30s debug capture with printer push), and system info. Reports create GitHub issues via a secure relay. Privacy-first: all logs are sanitized and sensitive data (IPs, serials, credentials) is never included.
 
 ### 🔒 Optional Authentication
 - Enable/disable authentication any time

README.md

@@ -2,7 +2,6 @@
 import json
 import logging
 import zipfile
-from datetime import date, datetime, time, timezone
 from decimal import ROUND_HALF_UP, Decimal
 from pathlib import Path
 
@@ -22,7 +21,7 @@
 from backend.app.models.filament import Filament
 from backend.app.models.spool_usage_history import SpoolUsageHistory
 from backend.app.models.user import User
-from backend.app.schemas.archive import ArchiveResponse, ArchiveSlim, ArchiveStats, ArchiveUpdate, ReprintRequest
+from backend.app.schemas.archive import ArchiveResponse, ArchiveStats, ArchiveUpdate, ReprintRequest
 from backend.app.services.archive import ArchiveService
 from backend.app.utils.threemf_tools import extract_nozzle_mapping_from_3mf
 
@@ -123,8 +122,6 @@ def archive_to_response(
 async def list_archives(
     printer_id: int | None = None,
     project_id: int | None = None,
-    date_from: date | None = Query(None),
-    date_to: date | None = Query(None),
     limit: int = 50,
     offset: int = 0,
     db: AsyncSession = Depends(get_db),
@@ -135,8 +132,6 @@ async def list_archives(
     archives = await service.list_archives(
         printer_id=printer_id,
         project_id=project_id,
-        date_from=date_from,
-        date_to=date_to,
         limit=limit,
         offset=offset,
     )
@@ -154,78 +149,6 @@ async def list_archives(
     return result
 
 
-@router.get("/slim", response_model=list[ArchiveSlim])
-async def list_archives_slim(
-    date_from: date | None = Query(None),
-    date_to: date | None = Query(None),
-    limit: int = Query(default=10000, le=50000),
-    offset: int = 0,
-    db: AsyncSession = Depends(get_db),
-    _: User | None = RequirePermissionIfAuthEnabled(Permission.ARCHIVES_READ),
-):
-    """Lightweight archive listing for stats/dashboard widgets.
-
-    Returns only the fields needed for client-side aggregation,
-    skipping duplicate detection, file paths, and extra_data.
-    """
-    filters = []
-    if date_from:
-        dt_from = datetime.combine(date_from, time.min, tzinfo=timezone.utc)
-        filters.append(PrintArchive.created_at >= dt_from)
-    if date_to:
-        dt_to = datetime.combine(date_to, time.max, tzinfo=timezone.utc)
-        filters.append(PrintArchive.created_at <= dt_to)
-
-    query = (
-        select(
-            PrintArchive.printer_id,
-            PrintArchive.print_name,
-            PrintArchive.print_time_seconds,
-            PrintArchive.started_at,
-            PrintArchive.completed_at,
-            PrintArchive.filament_used_grams,
-            PrintArchive.filament_type,
-            PrintArchive.filament_color,
-            PrintArchive.status,
-            PrintArchive.cost,
-            PrintArchive.quantity,
-            PrintArchive.created_at,
-        )
-        .where(*filters)
-        .order_by(PrintArchive.created_at.desc())
-        .limit(limit)
-        .offset(offset)
-    )
-    result = await db.execute(query)
-    rows = result.all()
-
-    return [
-        {
-            "printer_id": r.printer_id,
-            "print_name": r.print_name,
-            "print_time_seconds": r.print_time_seconds,
-            "actual_time_seconds": (
-                int((r.completed_at - r.started_at).total_seconds())
-                if r.started_at
-                and r.completed_at
-                and r.status == "completed"
-                and (r.completed_at - r.started_at).total_seconds() > 0
-                else None
-            ),
-            "filament_used_grams": r.filament_used_grams,
-            "filament_type": r.filament_type,
-            "filament_color": r.filament_color,
-            "status": r.status,
-            "started_at": r.started_at,
-            "completed_at": r.completed_at,
-            "cost": r.cost,
-            "quantity": r.quantity,
-            "created_at": r.created_at,
-        }
-        for r in rows
-    ]
-
-
 @router.get("/search", response_model=list[ArchiveResponse])
 async def search_archives(
     q: str = Query(..., min_length=2, description="Search query"),
@@ -354,9 +277,7 @@ async def rebuild_search_index(
 
 @router.get("/analysis/failures")
 async def analyze_failures(
-    days: int | None = None,
-    date_from: date | None = Query(None),
-    date_to: date | None = Query(None),
+    days: int = 30,
     printer_id: int | None = None,
     project_id: int | None = None,
     db: AsyncSession = Depends(get_db),
@@ -376,8 +297,6 @@ async def analyze_failures(
     service = FailureAnalysisService(db)
     return await service.analyze_failures(
         days=days,
-        date_from=date_from,
-        date_to=date_to,
         printer_id=printer_id,
         project_id=project_id,
     )
@@ -521,42 +440,25 @@ async def export_stats(
 
 @router.get("/stats", response_model=ArchiveStats)
 async def get_archive_stats(
-    date_from: date | None = Query(None, description="Start date (inclusive), YYYY-MM-DD"),
-    date_to: date | None = Query(None, description="End date (inclusive), YYYY-MM-DD"),
     db: AsyncSession = Depends(get_db),
     _: User | None = RequirePermissionIfAuthEnabled(Permission.STATS_READ),
 ):
     """Get statistics across all archives."""
-    # Build date filter conditions
-    base_conditions = []
-    if date_from:
-        dt_from = datetime.combine(date_from, time.min, tzinfo=timezone.utc)
-        base_conditions.append(PrintArchive.created_at >= dt_from)
-    if date_to:
-        dt_to = datetime.combine(date_to, time.max, tzinfo=timezone.utc)
-        base_conditions.append(PrintArchive.created_at <= dt_to)
-
     # Total counts
-    total_result = await db.execute(select(func.count(PrintArchive.id)).where(*base_conditions))
+    total_result = await db.execute(select(func.count(PrintArchive.id)))
     total_prints = total_result.scalar() or 0
 
-    successful_result = await db.execute(
-        select(func.count(PrintArchive.id)).where(PrintArchive.status == "completed", *base_conditions)
-    )
+    successful_result = await db.execute(select(func.count(PrintArchive.id)).where(PrintArchive.status == "completed"))
     successful_prints = successful_result.scalar() or 0
 
-    failed_result = await db.execute(
-        select(func.count(PrintArchive.id)).where(PrintArchive.status == "failed", *base_conditions)
-    )
+    failed_result = await db.execute(select(func.count(PrintArchive.id)).where(PrintArchive.status == "failed"))
     failed_prints = failed_result.scalar() or 0
 
     # Totals - use actual print time from timestamps (not slicer estimates)
     # For archives with both started_at and completed_at, calculate actual duration
     # Fall back to print_time_seconds only for archives without timestamps
     archives_for_time = await db.execute(
-        select(PrintArchive.started_at, PrintArchive.completed_at, PrintArchive.print_time_seconds).where(
-            *base_conditions
-        )
+        select(PrintArchive.started_at, PrintArchive.completed_at, PrintArchive.print_time_seconds)
     )
     total_seconds = 0
     for started_at, completed_at, print_time_seconds in archives_for_time.all():
@@ -571,17 +473,15 @@ async def get_archive_stats(
     total_time = total_seconds / 3600  # Convert to hours
 
     # Sum filament directly - filament_used_grams already contains the total for the print job
-    filament_result = await db.execute(
-        select(func.coalesce(func.sum(PrintArchive.filament_used_grams), 0)).where(*base_conditions)
-    )
+    filament_result = await db.execute(select(func.coalesce(func.sum(PrintArchive.filament_used_grams), 0)))
     total_filament = filament_result.scalar() or 0
 
-    cost_result = await db.execute(select(func.sum(PrintArchive.cost)).where(*base_conditions))
+    cost_result = await db.execute(select(func.sum(PrintArchive.cost)))
     total_cost = cost_result.scalar() or 0
 
     # By filament type (split comma-separated values for multi-material prints)
     filament_type_result = await db.execute(
-        select(PrintArchive.filament_type).where(PrintArchive.filament_type.isnot(None), *base_conditions)
+        select(PrintArchive.filament_type).where(PrintArchive.filament_type.isnot(None))
     )
     prints_by_filament: dict[str, int] = {}
     for (filament_types,) in filament_type_result.all():
@@ -593,17 +493,15 @@ async def get_archive_stats(
 
     # By printer
     printer_result = await db.execute(
-        select(PrintArchive.printer_id, func.count(PrintArchive.id))
-        .where(*base_conditions)
-        .group_by(PrintArchive.printer_id)
+        select(PrintArchive.printer_id, func.count(PrintArchive.id)).group_by(PrintArchive.printer_id)
     )
     prints_by_printer = {str(k): v for k, v in printer_result.all()}
 
     # Time accuracy statistics
     # Get all completed archives with both estimated and actual times
     accuracy_result = await db.execute(
         select(PrintArchive)
-        .where(PrintArchive.status == "completed", *base_conditions)
+        .where(PrintArchive.status == "completed")
         .where(PrintArchive.print_time_seconds.isnot(None))
         .where(PrintArchive.started_at.isnot(None))
         .where(PrintArchive.completed_at.isnot(None))
@@ -677,10 +575,10 @@ async def get_archive_stats(
         total_energy_cost = round(total_energy_kwh * energy_cost_per_kwh, 3)
     else:
         # Print mode: sum up per-print energy from archives
-        energy_kwh_result = await db.execute(select(func.sum(PrintArchive.energy_kwh)).where(*base_conditions))
+        energy_kwh_result = await db.execute(select(func.sum(PrintArchive.energy_kwh)))
         total_energy_kwh = energy_kwh_result.scalar() or 0
 
-        energy_cost_result = await db.execute(select(func.sum(PrintArchive.energy_cost)).where(*base_conditions))
+        energy_cost_result = await db.execute(select(func.sum(PrintArchive.energy_cost)))
         total_energy_cost = energy_cost_result.scalar() or 0
 
     return ArchiveStats(

backend/app/api/routes/archives.py

@@ -1,31 +1,24 @@
 from datetime import timedelta
-from typing import Annotated
 
-from fastapi import APIRouter, Depends, Header, HTTPException, status
-from fastapi.security import HTTPAuthorizationCredentials
+from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 
 from backend.app.api.routes.settings import get_external_login_url
 from backend.app.core.auth import (
     ACCESS_TOKEN_EXPIRE_MINUTES,
-    ALGORITHM,
-    SECRET_KEY,
     Permission,
     RequirePermissionIfAuthEnabled,
-    _validate_api_key,
     authenticate_user,
     authenticate_user_by_email,
     create_access_token,
     get_current_active_user,
     get_password_hash,
     get_user_by_email,
     get_user_by_username,
-    security,
 )
 from backend.app.core.database import get_db
-from backend.app.core.permissions import ALL_PERMISSIONS
 from backend.app.models.group import Group
 from backend.app.models.settings import Settings
 from backend.app.models.user import User
@@ -68,21 +61,6 @@ def _user_to_response(user: User) -> UserResponse:
     )
 
 
-def _api_key_to_user_response(api_key) -> UserResponse:
-    """Create a synthetic admin UserResponse for a valid API key."""
-    return UserResponse(
-        id=0,
-        username=f"api-key:{api_key.key_prefix}",
-        email=None,
-        role="admin",
-        is_active=True,
-        is_admin=True,
-        groups=[],
-        permissions=sorted(ALL_PERMISSIONS),
-        created_at=api_key.created_at.isoformat(),
-    )
-
-
 router = APIRouter(prefix="/auth", tags=["authentication"])
 
 
@@ -330,74 +308,14 @@ async def login(request: LoginRequest, db: AsyncSession = Depends(get_db)):
 
 @router.get("/me", response_model=UserResponse)
 async def get_current_user_info(
-    credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(security)] = None,
-    x_api_key: Annotated[str | None, Header(alias="X-API-Key")] = None,
+    current_user: User = Depends(get_current_active_user),
     db: AsyncSession = Depends(get_db),
 ):
-    """Get current user information.
-
-    Accepts JWT tokens (via Authorization: Bearer header) and API keys
-    (via X-API-Key header or Authorization: Bearer bb_xxx).
-    API keys return a synthetic admin user with all permissions.
-    """
-    import jwt
-    from jwt.exceptions import PyJWTError as JWTError
-
-    # Check for API key via X-API-Key header
-    if x_api_key:
-        api_key = await _validate_api_key(db, x_api_key)
-        if api_key:
-            return _api_key_to_user_response(api_key)
-
-    # Check for Bearer token (could be JWT or API key)
-    if credentials is not None:
-        token = credentials.credentials
-        # Check if it's an API key (starts with bb_)
-        if token.startswith("bb_"):
-            api_key = await _validate_api_key(db, token)
-            if api_key:
-                return _api_key_to_user_response(api_key)
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid API key",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-
-        # Otherwise treat as JWT
-        try:
-            payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-            username: str = payload.get("sub")
-            if username is None:
-                raise HTTPException(
-                    status_code=status.HTTP_401_UNAUTHORIZED,
-                    detail="Could not validate credentials",
-                    headers={"WWW-Authenticate": "Bearer"},
-                )
-        except JWTError:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Could not validate credentials",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-
-        user = await get_user_by_username(db, username)
-        if user is None or not user.is_active:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Could not validate credentials",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-        # Reload with groups for proper permission calculation
-        result = await db.execute(select(User).where(User.id == user.id).options(selectinload(User.groups)))
-        user = result.scalar_one()
-        return _user_to_response(user)
-
-    # No credentials provided
-    raise HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Authentication required",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
+    """Get current user information."""
+    # Reload user with groups for proper permission calculation
+    result = await db.execute(select(User).where(User.id == current_user.id).options(selectinload(User.groups)))
+    user = result.scalar_one()
+    return _user_to_response(user)
 
 
 @router.post("/logout")