Keycloak

backend/app/main.py

@@ -1,11 +1,12 @@
-from fastapi import FastAPI, Request, APIRouter
+from fastapi import FastAPI, Request, APIRouter, Depends
 from fastapi.responses import JSONResponse, Response
 from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import RequestValidationError
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.middleware.sessions import SessionMiddleware
 from .routers import auth, useCases, subUseCases, roles, transactions, properties, propertyGroups, users, ontology, standards
+from .crud.auth import get_current_user_from_token
 from .config import IMAGE_DIR, get_settings
 from .exceptions import VersionConflictError
 import logging
@@ -76,15 +77,16 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE
     secret_key=get_settings().session_secret_key,
 )
 
-api = APIRouter(prefix="/api")
+api = APIRouter(prefix="/api", dependencies=[Depends(get_current_user_from_token)])
+
 
-@api.get("/health")
-def health() -> Response:
-    return Response(content="ok\n", media_type="text/plain")
 
 app.mount("/static/images", StaticFiles(directory=IMAGE_DIR), name="images")
 
-api.include_router(auth.auth_router)
+# Public auth endpoints (no token required)
+app.include_router(auth.auth_router, prefix="/api")
+
+# Authenticated API routes
 api.include_router(users.user_router)
 api.include_router(useCases.router)
 api.include_router(subUseCases.router)
@@ -95,3 +97,8 @@ def health() -> Response:
 api.include_router(ontology.router)
 api.include_router(standards.router)
 app.include_router(api)
+
+# Public health endpoint (no auth required)
+@app.get("/api/health")
+def health() -> Response:
+    return Response(content="ok\n", media_type="text/plain")

backend/app/routers/properties.py

@@ -2,7 +2,7 @@
 from sqlalchemy.orm import Session
 from ..schemas.logs import VersionInfo
 from ..models.users import User
-from ..crud.auth import get_current_user_from_token, require_role, RoleEnum
+from ..crud.auth import require_role, RoleEnum
 from ..db import get_db
 from ..crud import properties as crud
 from ..schemas.properties import *
@@ -37,13 +37,13 @@ def get_property_version(uuid: UUID, db: Session = Depends(get_db)):
 
 # --------CREATE-------
 @router.post("/", response_model=PropertyResponse, status_code=201)
-def create_property(prop: PropertyCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def create_property(prop: PropertyCreate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     return crud.create_property(db, prop, current_user.username)
 
 
 # --------UPDATE-------
 @router.put("/{uuid}", response_model=PropertyResponse)
-def update_property(uuid: UUID, prop: PropertyUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def update_property(uuid: UUID, prop: PropertyUpdate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     updated = crud.update_property(db, uuid, prop, current_user.username)
     if not updated:
         raise HTTPException(status_code=404, detail="Property not found")
@@ -52,7 +52,7 @@ def update_property(uuid: UUID, prop: PropertyUpdate, db: Session = Depends(get_
 
 # --------DELETE-------
 @router.delete("/{uuid}", status_code=204)
-def delete_property(uuid: UUID, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def delete_property(uuid: UUID, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     success = crud.delete_property(db, uuid, current_user.username)
     if not success:
         raise HTTPException(status_code=404, detail="Property not found")

backend/app/routers/propertyGroups.py

@@ -2,7 +2,7 @@
 from sqlalchemy.orm import Session
 from ..db import get_db
 from ..models.users import User
-from ..crud.auth import get_current_user_from_token, require_role, RoleEnum
+from ..crud.auth import require_role, RoleEnum
 from ..crud import propertyGroups as crud
 from ..schemas.propertyGroups import *
 from ..schemas.logs import VersionInfo
@@ -43,20 +43,20 @@ def get_propertyGroup_version(uuid: UUID, db: Session = Depends(get_db)):
 
 # --------CREATE-------
 @router.post("/", response_model=PropertyGroupResponse, status_code=201)
-def create_propertyGroup(property_group: PropertyGroupCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def create_propertyGroup(property_group: PropertyGroupCreate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     return crud.create_propertyGroup(db, property_group, current_user.username)
 
 # --------UPDATE-------
 @router.put("/{uuid}", response_model=PropertyGroupResponse)
-def update_propertyGroup(uuid: UUID, property_group: PropertyGroupUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def update_propertyGroup(uuid: UUID, property_group: PropertyGroupUpdate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     updated = crud.update_propertyGroup(db, uuid, property_group, current_user.username)
     if not updated:
         raise HTTPException(status_code=404, detail="Property Group not found")
     return updated
 
 # --------DELETE-------
 @router.delete("/{uuid}", status_code=204)
-def delete_propertyGroup(uuid: UUID, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def delete_propertyGroup(uuid: UUID, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     success = crud.delete_propertyGroup(db, uuid, current_user.username)
     if not success:
         raise HTTPException(status_code=404, detail="Property Group not found")

backend/app/routers/roles.py

@@ -1,7 +1,7 @@
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from ..models.users import User
-from ..crud.auth import get_current_user_from_token, require_role, RoleEnum
+from ..crud.auth import require_role, RoleEnum
 from ..crud import roles as crud
 from ..db import get_db
 from ..schemas.roles import *
@@ -31,20 +31,20 @@ def get_role_version(id: int, db: Session = Depends(get_db)):
 
 # ---------CREATE--------
 @router.post("/", response_model=Role)
-def create_role(data: RoleMutate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def create_role(data: RoleMutate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     return crud.create_role(db, data, current_user.username)
 
 # ---------UPDATE--------
 @router.put("/{id}", response_model=Role)
-def update_role(id: int, data: RoleMutate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def update_role(id: int, data: RoleMutate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     role = crud.get_role_by_id(db, id)
     if not role:
         raise HTTPException(status_code=404, detail="Rolle nicht gefunden")
     return crud.update_role(db, id, data, current_user.username)
 
 # ---------DELETE--------
 @router.delete("/{id}", status_code=204)
-def delete_role(id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def delete_role(id: int, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     role = crud.get_role_by_id(db, id)
     if not role:
         raise HTTPException(status_code=404, detail="Rolle nicht gefunden")

backend/app/routers/standards.py

@@ -3,7 +3,7 @@
 from ..db import get_db
 from ..crud import standards as crud
 from ..models.users import User
-from ..crud.auth import get_current_user_from_token, require_role, RoleEnum
+from ..crud.auth import require_role, RoleEnum
 from ..schemas.standards import *
 from ..schemas.logs import VersionInfo
 
@@ -31,12 +31,12 @@ def get_standard_version(id: int, db: Session = Depends(get_db)):
 
 # ---------CREATE--------
 @router.post("/", response_model=Standard)
-def create_standard(data: StandardMutate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def create_standard(data: StandardMutate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     return crud.create_standard(db, data, current_user.username)
 
 # ---------UPDATE--------
 @router.put("/{id}", response_model=Standard)
-def update_standard(id: int, data: StandardMutate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def update_standard(id: int, data: StandardMutate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     standard = crud.get_standard_by_id(db, id)
     if not standard:
         raise HTTPException(status_code=404, detail="Standard nicht gefunden")
@@ -45,7 +45,7 @@ def update_standard(id: int, data: StandardMutate, db: Session = Depends(get_db)
 
 # ---------DELETE--------
 @router.delete("/{id}", status_code=204)
-def delete_standard(id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def delete_standard(id: int, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     standard = crud.get_standard_by_id(db, id)
     if not standard:
         raise HTTPException(status_code=404, detail="Standard nicht gefunden")

backend/app/routers/subUseCases.py

@@ -5,7 +5,7 @@
 from sqlalchemy.orm import Session
 from xml.etree import ElementTree as ET
 from ..models.users import User
-from ..crud.auth import get_current_user_from_token, require_role, RoleEnum
+from ..crud.auth import require_role, RoleEnum
 from ..db import get_db
 from ..crud import subUseCases as crud
 from ..schemas.subUseCases import *
@@ -40,20 +40,20 @@ def list_subUseCases_by_role(role_id: int, db: Session = Depends(get_db)):
 
 # --------CREATE--------
 @router.post("/", response_model=SubUseCase)
-def create_subUseCase(data: SubUseCaseCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def create_subUseCase(data: SubUseCaseCreate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     return crud.create_subUseCase(db, data, current_user.username)
 
 # --------UPDATE--------
 @router.put("/{id}", response_model=SubUseCase)
-def update_subUseCase(id: int, data: SubUseCaseUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def update_subUseCase(id: int, data: SubUseCaseUpdate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     subUseCase = crud.get_subUseCase_by_id(db, id)
     if not subUseCase:
         raise HTTPException(status_code=404, detail="Sub Use Case nicht gefunden")
     return crud.update_subUseCase(db, id, data, current_user.username)
 
 # ---------DELETE--------
 @router.delete("/{id}", status_code=204)
-def delete_subUseCase(id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def delete_subUseCase(id: int, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     subUseCase = crud.get_subUseCase_by_id(db, id)
     if not subUseCase:
         raise HTTPException(status_code=404, detail="Sub Use Case nicht gefunden")

backend/app/routers/transactions.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
-from ..crud.auth import get_current_user_from_token, require_role, RoleEnum
+from ..crud.auth import require_role, RoleEnum
 from ..db import get_db
 from ..crud import transactions as crud
 from ..models.users import User
@@ -35,20 +35,20 @@ def list_transactions_by_subusecase(sub_id: int, db: Session = Depends(get_db)):
 
 # --------CREATE-------
 @router.post("/", response_model=Transaction)
-def create_transaction(data: TransactionMutate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def create_transaction(data: TransactionMutate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     return crud.create_transaction(db, data, current_user.username)
 
 # --------UPDATE-------
 @router.put("/{id}", response_model=Transaction)
-def update_transaction(id: int, data: TransactionMutate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def update_transaction(id: int, data: TransactionMutate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     transaction = crud.get_transaction_by_id(db, id)
     if not transaction:
         raise HTTPException(status_code=404, detail="Transaktion nicht gefunden")
     return crud.update_transaction(db, id, data, current_user.username)
 
 # --------DELETE-------
 @router.delete("/{id}", status_code=204)
-def delete_transaction(id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def delete_transaction(id: int, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     transaction = crud.get_transaction_by_id(db, id)
     if not transaction:
         raise HTTPException(status_code=404, detail="Transaktion nicht gefunden")

backend/app/routers/useCases.py

@@ -6,7 +6,7 @@
 from ..models.users import User
 from ..schemas.useCases import *
 from ..schemas.logs import *
-from ..crud.auth import require_role, RoleEnum, get_current_user_from_token
+from ..crud.auth import require_role, RoleEnum
 
 router = APIRouter(prefix="/usecases", tags=["Use Cases"], dependencies=[Depends(require_role(RoleEnum.READ))])
 
@@ -32,15 +32,15 @@ def get_useCase_version(id: int, db: Session = Depends(get_db)):
 
 # ---------CREATE--------
 @router.post("/", response_model=UseCase)
-def create_useCase(data: UseCaseCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def create_useCase(data: UseCaseCreate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     roles = db.query(models.Role).filter(models.Role.id.in_(data.roles)).all()
     if len(roles) != len(data.roles):
         raise HTTPException(status_code=400, detail="Eine oder mehrere Rollen nicht gefunden")
     return crud.create_useCase(db, data, roles, current_user.username)
 
 # ---------UPDATE--------
 @router.put("/{id}", response_model=UseCase)
-def update_useCase(id: int, data: UseCaseUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def update_useCase(id: int, data: UseCaseUpdate, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     roles = db.query(models.Role).filter(models.Role.id.in_(data.roles)).all()
     if len(roles) != len(data.roles):
         raise HTTPException(status_code=400, detail="Eine oder mehrere Rollen nicht gefunden")
@@ -54,7 +54,7 @@ def update_useCase(id: int, data: UseCaseUpdate, db: Session = Depends(get_db),
 
 # ---------DELETE--------
 @router.delete("/{id}", status_code=204)
-def delete_useCase(id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user_from_token)):
+def delete_useCase(id: int, db: Session = Depends(get_db), current_user: User = Depends(require_role(RoleEnum.WRITE))):
     useCase = crud.get_useCase_by_id(db, id)
     if not useCase:
         raise HTTPException(status_code=404, detail="Use Case nicht gefunden")