Ja, natürlich! Hier ist eine Vorlage für eine REST-API für einen Adventskalender mit FastAPI und SQLAlchemy, die CRUD-Operationen für den Kalender, die Fragen und die Benutzerfunktionen enthält. Die Datenbank wird über eine SQLite-Datenbank realisiert.

```python
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship

# Erstelle die FastAPI-App
app = FastAPI()

# Erstelle die SQLite-Datenbank
engine = create_engine('sqlite:///adventskalender.db')
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()


# Definiere die Modelle

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True)
    password = Column(String)


class Calendar(Base):
    __tablename__ = 'calendar'

    id = Column(Integer, primary_key=True, index=True)
    question = Column(String)
    correct_answer = Column(String)


class Answer(Base):
    __tablename__ = 'answers'

    id = Column(Integer, primary_key=True, index=True)
    user_id = Column(Integer, ForeignKey('users.id'))
    calendar_id = Column(Integer, ForeignKey('calendar.id'))
    answer = Column(String)
    is_correct = Column(Integer)


Base.metadata.create_all(bind=engine)


# Pydantic-Schemas

class UserCreate(BaseModel):
    username: str
    password: str


class UserLogin(BaseModel):
    username: str
    password: str


class CalendarCreate(BaseModel):
    question: str
    correct_answer: str


class AnswerCreate(BaseModel):
    answer: str


# Datenbankfunktionen

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


# CRUD-Operationen für Benutzer

@app.post("/users/register")
def create_user(user: UserCreate, db: Session = Depends(get_db)):
    existing_user = db.query(User).filter(User.username == user.username).first()
    if existing_user:
        raise HTTPException(status_code=400, detail="Username already registered")
    new_user = User(username=user.username, password=user.password)
    db.add(new_user)
    db.commit()
    db.refresh(new_user)
    return {"username": new_user.username}


@app.post("/users/login")
def user_login(user: UserLogin, db: Session = Depends(get_db)):
    db_user = db.query(User).filter(User.username == user.username).first()
    if db_user and db_user.password == user.password:
        return {"username": db_user.username}
    raise HTTPException(status_code=401, detail="Invalid username or password")


# CRUD-Operationen für den Adventskalender

@app.post("/calendar", response_model=CalendarCreate)
def create_calendar(calendar: CalendarCreate, db: Session = Depends(get_db)):
    new_calendar = Calendar(question=calendar.question, correct_answer=calendar.correct_answer)
    db.add(new_calendar)
    db.commit()
    db.refresh(new_calendar)
    return new_calendar


@app.get("/calendar/{calendar_id}")
def get_calendar(calendar_id: int, db: Session = Depends(get_db)):
    calendar = db.query(Calendar).filter(Calendar.id == calendar_id).first()
    if not calendar:
        raise HTTPException(status_code=404, detail="Calendar not found")
    return calendar


# CRUD-Operationen für die Antworten

@app

.post("/answers", response_model=AnswerCreate)
def create_answer(answer: AnswerCreate, calendar_id: int, current_user: User = Depends(get_current_user),
                  db: Session = Depends(get_db)):
    calendar = db.query(Calendar).filter(Calendar.id == calendar_id).first()
    if not calendar:
        raise HTTPException(status_code=404, detail="Calendar not found")
    is_correct = 1 if answer.answer == calendar.correct_answer else 0
    new_answer = Answer(user_id=current_user.id, calendar_id=calendar.id, answer=answer.answer, is_correct=is_correct)
    db.add(new_answer)
    db.commit()
    db.refresh(new_answer)
    return new_answer


@app.get("/answers/{answer_id}")
def get_answer(answer_id: int, db: Session = Depends(get_db)):
    answer = db.query(Answer).filter(Answer.id == answer_id).first()
    if not answer:
        raise HTTPException(status_code=404, detail="Answer not found")
    return answer


# Schutz der Routen mit Token-Authentifizierung

# Implementiere die Authentifizierungsfunktionen (z.B. mit JWT)

# Implementiere eine Funktion, um den aktuellen Benutzer basierend auf dem Authentifizierungstoken zu erhalten

# Verwende die `Depends(get_current_user)`-Annotation, um den aktuellen Benutzer in den Routen zu erhalten


# Beispielimplementationen der Token-Authentifizierungsfunktionen
# Achtung: Diese Beispielimplementationen sind nicht sicher und sollten entsprechend angepasst werden!

# def authenticate_user(username: str, password: str, db: Session):
#     user = db.query(User).filter(User.username == username).first()
#     if not user or user.password != password:
#         return False
#     return user


# def create_access_token(data: dict, expires_delta: timedelta):
#     to_encode = data.copy()
#     expire = datetime.utcnow() + expires_delta
#     to_encode.update({"exp": expire})
#     encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
#     return encoded_jwt


# def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
#     try:
#         payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
#         username: str = payload.get("sub")
#         if username is None:
#             raise HTTPException(status_code=401, detail="Invalid authentication credentials")
#         token_data = TokenData(username=username)
#     except JWTError:
#         raise HTTPException(status_code=401, detail="Invalid authentication credentials")
#
#     user = db.query(User).filter(User.username == token_data.username).first()
#     if user is None:
#         raise HTTPException(status_code=401, detail="Invalid username")
#     return user


# Beispielimplementationen der Token-Authentifizierungsfunktionen (Fortsetzung)
# Achtung: Diese Beispielimplementationen sind nicht sicher und sollten entsprechend angepasst werden!

# Beispielroute für den Erhalt eines Authentifizierungstokens
# In diesem Beispiel wird einfach ein JWT erstellt und zurückgegeben
# Der `create_access_token`-Funktion muss mit den richtigen Parametern aufgerufen werden

# from datetime import timedelta
# from fastapi.security import OAuth2PasswordBearer
# from jose import JWTError, jwt
# from passlib.context import CryptContext
# from datetime import datetime

# oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")
# pwd_context = CryptContext

(schemes=["bcrypt"], deprecated="auto")
# SECRET_KEY = "SECRET"
# ALGORITHM = "HS256"

# Beispielroute für den Erhalt eines Authentifizierungstokens
# In diesem Beispiel wird einfach ein JWT erstellt und zurückgegeben
# Der `create_access_token`-Funktion muss mit den richtigen Parametern aufgerufen werden

# def authenticate_user(username: str, password: str, db: Session):
#     user = db.query(User).filter(User.username == username).first()
#     if not user or not pwd_context.verify(password, user.password):
#         return False
#     return user


# def create_access_token(data: dict, expires_delta: timedelta):
#     to_encode = data.copy()
#     expire = datetime.utcnow() + expires_delta
#     to_encode.update({"exp": expire})
#     encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
#     return encoded_jwt


# def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
#     try:
#         payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
#         username: str = payload.get("sub")
#         if username is None:
#             raise HTTPException(status_code=401, detail="Invalid authentication credentials")
#         token_data = TokenData(username=username)
#     except JWTError:
#         raise HTTPException(status_code=401, detail="Invalid authentication credentials")
#
#     user = db.query(User).filter(User.username == token_data.username).first()
#     if user is None:
#         raise HTTPException(status_code=401, detail="Invalid username")
#     return user
```

Beachte, dass die Token-Authentifizierungsfunktionen (`authenticate_user`, `create_access_token` und `get_current_user`) nur als Beispielimplementationen dienen und entsprechend angepasst werden sollten, um eine sichere Authentifizierung zu gewährleisten.

Außerdem solltest du die Datei `adventskalender.db` erstellen, um die SQLite-Datenbank zu initialisieren. Dazu kannst du das `sqlite3`-Modul in Python verwenden oder eine SQLite-Clientanwendung wie SQLiteStudio.

Diese Vorlage enthält die grundlegenden CRUD-Operationen für die Benutzer, den Adventskalender und die Antworten. Du kannst sie erweitern und an deine spezifischen Anforderungen anpassen.
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence