303 lines
10 KiB
Python
303 lines
10 KiB
Python
from fastapi import BackgroundTasks, FastAPI, Depends, HTTPException, status
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from sqlalchemy import text
|
|
from datetime import datetime, timedelta, timezone
|
|
from zoneinfo import ZoneInfo
|
|
from database.database import SessionLocal, Base, engine
|
|
from database.models import Document, ScraperRun, User
|
|
|
|
from api.auth import (
|
|
UserLogin, UserCreate, Token, UserResponse, RoleUpdate,
|
|
get_password_hash, verify_password,
|
|
create_access_token, decode_token, ACCESS_TOKEN_EXPIRE_MINUTES
|
|
)
|
|
|
|
Base.metadata.create_all(bind=engine)
|
|
|
|
app = FastAPI()
|
|
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=["*"],
|
|
allow_credentials=True,
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
|
|
def require_admin(token: str):
|
|
email = decode_token(token)
|
|
if not email:
|
|
raise HTTPException(status_code=401, detail="Invalid token")
|
|
db = SessionLocal()
|
|
user = db.query(User).filter(User.email == email).first()
|
|
db.close()
|
|
if not user or user.role != "admin":
|
|
raise HTTPException(status_code=403, detail="Accès refusé")
|
|
return user
|
|
|
|
|
|
@app.get("/")
|
|
def root():
|
|
return {"message": "RegWatch API running"}
|
|
|
|
@app.post("/signup", response_model=UserResponse)
|
|
def signup(user: UserCreate):
|
|
db = SessionLocal()
|
|
existing_user = db.query(User).filter(User.email == user.email).first()
|
|
if existing_user:
|
|
db.close()
|
|
raise HTTPException(status_code=400, detail="Email already registered")
|
|
hashed_password = get_password_hash(user.password)
|
|
db_user = User(email=user.email, password=hashed_password, full_name=user.full_name)
|
|
db.add(db_user)
|
|
db.commit()
|
|
db.refresh(db_user)
|
|
db.close()
|
|
return UserResponse(id=db_user.id, email=db_user.email, full_name=db_user.full_name, role=db_user.role)
|
|
|
|
@app.post("/login", response_model=Token)
|
|
def login(credentials: UserLogin):
|
|
try:
|
|
db = SessionLocal()
|
|
user = db.query(User).filter(User.email == credentials.email).first()
|
|
db.close()
|
|
if not user:
|
|
raise HTTPException(status_code=401, detail="User not found")
|
|
if not verify_password(credentials.password, user.password):
|
|
raise HTTPException(status_code=401, detail="Invalid password")
|
|
access_token = create_access_token(
|
|
data={"sub": user.email},
|
|
expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
|
|
)
|
|
return Token(access_token=access_token, token_type="bearer")
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")
|
|
|
|
@app.get("/me", response_model=UserResponse)
|
|
def get_current_user(token: str):
|
|
email = decode_token(token)
|
|
if not email:
|
|
raise HTTPException(status_code=401, detail="Invalid token")
|
|
db = SessionLocal()
|
|
user = db.query(User).filter(User.email == email).first()
|
|
db.close()
|
|
if not user:
|
|
raise HTTPException(status_code=404, detail="User not found")
|
|
return UserResponse(id=user.id, email=user.email, full_name=user.full_name, role=user.role)
|
|
|
|
@app.get("/documents")
|
|
def get_documents():
|
|
db = SessionLocal()
|
|
documents = db.query(Document).all()
|
|
result = []
|
|
for doc in documents:
|
|
result.append({
|
|
"id": doc.id,
|
|
"title": doc.title,
|
|
"ingredient": doc.ingredient,
|
|
"source": doc.source,
|
|
"type": doc.document_type,
|
|
"date": doc.meeting_date,
|
|
"pdf_url": doc.pdf_url
|
|
})
|
|
db.close()
|
|
return result
|
|
|
|
|
|
@app.post("/admin/migrate-add-role")
|
|
def migrate_add_role():
|
|
db = SessionLocal()
|
|
try:
|
|
db.execute(text("ALTER TABLE users ADD COLUMN IF NOT EXISTS role VARCHAR DEFAULT 'user'"))
|
|
db.commit()
|
|
return {"message": "Colonne role ajoutée avec succès"}
|
|
except Exception as e:
|
|
return {"message": str(e)}
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
@app.post("/admin/make-admin")
|
|
def make_admin(token: str, target_email: str):
|
|
db = SessionLocal()
|
|
existing_admins = db.query(User).filter(User.role == "admin").count()
|
|
|
|
if existing_admins > 0:
|
|
# Il y a déjà un admin — vérifier que l'appelant est admin
|
|
email = decode_token(token)
|
|
caller = db.query(User).filter(User.email == email).first()
|
|
if not caller or caller.role != "admin":
|
|
db.close()
|
|
raise HTTPException(status_code=403, detail="Accès refusé")
|
|
|
|
target = db.query(User).filter(User.email == target_email).first()
|
|
if not target:
|
|
db.close()
|
|
raise HTTPException(status_code=404, detail="Utilisateur introuvable")
|
|
|
|
target.role = "admin"
|
|
db.commit()
|
|
db.close()
|
|
return {"message": f"{target_email} est maintenant admin"}
|
|
|
|
|
|
@app.get("/admin/stats")
|
|
def admin_stats(token: str):
|
|
require_admin(token)
|
|
db = SessionLocal()
|
|
total_docs = db.query(Document).count()
|
|
cir_docs = db.query(Document).filter(Document.source == "CIR").count()
|
|
sccs_docs = db.query(Document).filter(Document.source == "SCCS").count()
|
|
total_users = db.query(User).count()
|
|
db.close()
|
|
return {
|
|
"total_documents": total_docs,
|
|
"cir_documents": cir_docs,
|
|
"sccs_documents": sccs_docs,
|
|
"total_users": total_users
|
|
}
|
|
|
|
@app.get("/admin/users")
|
|
def admin_get_users(token: str):
|
|
require_admin(token)
|
|
db = SessionLocal()
|
|
users = db.query(User).all()
|
|
result = [{"id": u.id, "email": u.email, "full_name": u.full_name, "role": u.role} for u in users]
|
|
db.close()
|
|
return result
|
|
|
|
@app.delete("/admin/users/{user_id}")
|
|
def admin_delete_user(user_id: int, token: str):
|
|
require_admin(token)
|
|
db = SessionLocal()
|
|
user = db.query(User).filter(User.id == user_id).first()
|
|
if not user:
|
|
db.close()
|
|
raise HTTPException(status_code=404, detail="Utilisateur introuvable")
|
|
db.delete(user)
|
|
db.commit()
|
|
db.close()
|
|
return {"message": "Utilisateur supprimé"}
|
|
|
|
@app.patch("/admin/users/{user_id}/role")
|
|
def admin_update_role(user_id: int, role_update: RoleUpdate, token: str):
|
|
require_admin(token)
|
|
db = SessionLocal()
|
|
user = db.query(User).filter(User.id == user_id).first()
|
|
if not user:
|
|
db.close()
|
|
raise HTTPException(status_code=404, detail="Utilisateur introuvable")
|
|
user.role = role_update.role
|
|
db.commit()
|
|
db.close()
|
|
return {"message": f"Rôle mis à jour : {role_update.role}"}
|
|
|
|
@app.delete("/admin/documents/{doc_id}")
|
|
def admin_delete_document(doc_id: int, token: str):
|
|
require_admin(token)
|
|
db = SessionLocal()
|
|
doc = db.query(Document).filter(Document.id == doc_id).first()
|
|
if not doc:
|
|
db.close()
|
|
raise HTTPException(status_code=404, detail="Document introuvable")
|
|
db.delete(doc)
|
|
db.commit()
|
|
db.close()
|
|
return {"message": "Document supprimé"}
|
|
# ── Scrapers ─────────────────────────────────────────────────
|
|
# Les scrapers tournent aussi via le cron hôte (scripts/regwatch-scrape.sh,
|
|
# dimanche 3h). Ces endpoints permettent de les déclencher à la demande depuis
|
|
# la page admin et de consulter l'historique des exécutions.
|
|
|
|
SCRAPER_SOURCES = ("CIR", "SCCS")
|
|
PARIS = ZoneInfo("Europe/Paris")
|
|
|
|
def _serialize_run(run: ScraperRun) -> dict:
|
|
started = run.started_at.astimezone(PARIS) if run.started_at else None
|
|
return {
|
|
"id": str(run.id),
|
|
"when": started.strftime("%d/%m/%Y %H:%M") if started else "—",
|
|
"source": run.source,
|
|
"status": run.status,
|
|
"documents_added": run.documents_added or 0,
|
|
"message": run.message,
|
|
}
|
|
|
|
def _execute_scraper(run_id: int, source: str) -> None:
|
|
"""Exécuté en tâche de fond : lance le scraper puis clôt la ligne de journal."""
|
|
# Import tardif : ollama/pdfplumber/bs4 sont lourds, inutile de les charger
|
|
# au démarrage de l'API alors qu'ils ne servent qu'ici.
|
|
from scrapers.cir_scraper import scrape_cir
|
|
from scrapers.sccs_scraper import scrape_sccs
|
|
|
|
db = SessionLocal()
|
|
run = db.query(ScraperRun).filter(ScraperRun.id == run_id).first()
|
|
run.status = "running"
|
|
db.commit()
|
|
before = db.query(Document).filter(Document.source == source).count()
|
|
db.close()
|
|
|
|
status, message = "success", None
|
|
try:
|
|
if source == "CIR":
|
|
scrape_cir()
|
|
else:
|
|
scrape_sccs()
|
|
except Exception as exc:
|
|
status, message = "error", str(exc)[:500]
|
|
|
|
db = SessionLocal()
|
|
run = db.query(ScraperRun).filter(ScraperRun.id == run_id).first()
|
|
run.status = status
|
|
run.message = message
|
|
run.documents_added = max(db.query(Document).filter(Document.source == source).count() - before, 0)
|
|
run.finished_at = datetime.now(timezone.utc)
|
|
db.commit()
|
|
db.close()
|
|
|
|
@app.get("/admin/scrapers/logs")
|
|
def admin_scraper_logs(token: str, limit: int = 20):
|
|
require_admin(token)
|
|
db = SessionLocal()
|
|
runs = db.query(ScraperRun).order_by(ScraperRun.id.desc()).limit(limit).all()
|
|
result = [_serialize_run(r) for r in runs]
|
|
db.close()
|
|
return result
|
|
|
|
@app.post("/admin/scrapers/run")
|
|
def admin_scraper_run(token: str, source: str, background_tasks: BackgroundTasks):
|
|
require_admin(token)
|
|
|
|
source = source.upper()
|
|
if source not in SCRAPER_SOURCES:
|
|
raise HTTPException(status_code=400, detail=f"Source inconnue : {source}")
|
|
|
|
db = SessionLocal()
|
|
already = (
|
|
db.query(ScraperRun)
|
|
.filter(ScraperRun.source == source, ScraperRun.status.in_(("pending", "running")))
|
|
.first()
|
|
)
|
|
if already:
|
|
payload = _serialize_run(already)
|
|
db.close()
|
|
raise HTTPException(status_code=409, detail=f"Un scraper {source} est déjà en cours (#{payload['id']})")
|
|
|
|
run = ScraperRun(
|
|
source=source,
|
|
status="pending",
|
|
started_at=datetime.now(timezone.utc),
|
|
documents_added=0,
|
|
)
|
|
db.add(run)
|
|
db.commit()
|
|
db.refresh(run)
|
|
payload = _serialize_run(run)
|
|
run_id = run.id
|
|
db.close()
|
|
|
|
background_tasks.add_task(_execute_scraper, run_id, source)
|
|
return payload
|