Add files via upload

app/routers/items.py

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+
+from app import database, schemas
+from app.limiter import limiter
+from app.services.item_service import ItemService
+from app.services.scheduler_service import process_item_check
+
+router = APIRouter(prefix="/items", tags=["items"])
+
+
+@router.get("", response_model=list[schemas.ItemResponse])
+def get_items(db: Session = Depends(database.get_db)):
+    return ItemService.get_items(db)
+
+
+@router.post("", response_model=schemas.ItemResponse)
+def create_item(item: schemas.ItemCreate, db: Session = Depends(database.get_db)):
+    return ItemService.create_item(db, item)
+
+
+@router.put("/{item_id}", response_model=schemas.ItemResponse)
+def update_item(item_id: int, item_update: schemas.ItemCreate, db: Session = Depends(database.get_db)):
+    return ItemService.update_item(db, item_id, item_update)
+
+
+@router.delete("/{item_id}")
+def delete_item(item_id: int, db: Session = Depends(database.get_db)):
+    return ItemService.delete_item(db, item_id)
+
+
+@router.post("/{item_id}/check")
+@limiter.limit("10/minute")
+def check_item(
+    request: Request, item_id: int, background_tasks: BackgroundTasks, db: Session = Depends(database.get_db)
+):
+    item = ItemService.get_item(db, item_id)
+    if not item:
+        raise HTTPException(status_code=404, detail="Item not found")
+
+    item.is_refreshing = True
+    item.last_error = None
+    db.commit()
+
+    background_tasks.add_task(process_item_check, item_id)
+    return {"message": "Check triggered"}

app/routers/jobs.py

@@ -0,0 +1,61 @@
+from apscheduler.triggers.interval import IntervalTrigger
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+
+from app import database, models, schemas
+from app.limiter import limiter
+from app.services.scheduler_service import process_item_check, scheduled_refresh, scheduler
+from app.services.settings_service import SettingsService
+
+router = APIRouter(prefix="/jobs", tags=["jobs"])
+
+
+@router.get("/config")
+def get_job_config(db: Session = Depends(database.get_db)):
+    interval = int(SettingsService.get_setting_value(db, "refresh_interval_minutes", "60"))
+
+    next_run = None
+    job = scheduler.get_job("refresh_job")
+    if job:
+        next_run = job.next_run_time
+
+    return {"refresh_interval_minutes": interval, "next_run": next_run, "running": scheduler.running}
+
+
+@router.post("/config")
+def update_job_config(config: schemas.SettingsUpdate, db: Session = Depends(database.get_db)):
+    if config.key != "refresh_interval_minutes":
+        raise HTTPException(status_code=400, detail="Invalid setting key for job config")
+
+    try:
+        interval = int(config.value)
+        if interval < 1:
+            raise ValueError("Interval must be at least 1 minute")
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail="Invalid interval value") from e
+
+    SettingsService.update_setting(db, config)
+
+    try:
+        scheduler.reschedule_job("refresh_job", trigger=IntervalTrigger(minutes=interval))
+    except Exception:
+        scheduler.add_job(scheduled_refresh, IntervalTrigger(minutes=interval), id="refresh_job", replace_existing=True)
+
+    return {"message": "Job configuration updated", "refresh_interval_minutes": interval}
+
+
+@router.post("/refresh-all")
+@limiter.limit("5/minute")
+def refresh_all_items(request: Request, background_tasks: BackgroundTasks, db: Session = Depends(database.get_db)):
+    items = db.query(models.Item).filter(models.Item.is_active).all()
+
+    # Mark all items as refreshing immediately so UI updates persist
+    for item in items:
+        item.is_refreshing = True
+    db.commit()
+
+    for item in items:
+        if item.id is not None:
+            background_tasks.add_task(process_item_check, int(item.id))
+
+    return {"message": f"Triggered refresh for {len(items)} items"}

app/routers/notifications.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import database, schemas
+from app.services.notification_service import NotificationService
+
+router = APIRouter(prefix="/notification-profiles", tags=["notifications"])
+
+
+@router.get("", response_model=list[schemas.NotificationProfileResponse])
+def get_notification_profiles(db: Session = Depends(database.get_db)):
+    return NotificationService.get_notification_profiles(db)
+
+
+@router.post("", response_model=schemas.NotificationProfileResponse)
+def create_notification_profile(profile: schemas.NotificationProfileCreate, db: Session = Depends(database.get_db)):
+    return NotificationService.create_notification_profile(db, profile)
+
+
+@router.delete("/{profile_id}")
+def delete_notification_profile(profile_id: int, db: Session = Depends(database.get_db)):
+    return NotificationService.delete_notification_profile(db, profile_id)
+
+
+@router.put("/{profile_id}", response_model=schemas.NotificationProfileResponse)
+def update_notification_profile(
+    profile_id: int, profile: schemas.NotificationProfileUpdate, db: Session = Depends(database.get_db)
+):
+    return NotificationService.update_notification_profile(db, profile_id, profile)

app/routers/settings.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import database, schemas
+from app.services.settings_service import SettingsService
+
+router = APIRouter(prefix="/settings", tags=["settings"])
+
+
+@router.get("")
+def get_settings(db: Session = Depends(database.get_db)):
+    return SettingsService.get_settings(db)
+
+
+@router.post("", response_model=schemas.SettingsUpdate)
+def update_setting(setting: schemas.SettingsUpdate, db: Session = Depends(database.get_db)):
+    return SettingsService.update_setting(db, setting)