1 Commits
Author SHA1 Message Date
Rudi 383ba32a2e Database basefiles
Base Datauen für die Datenbank
2026-08-22 23:57:48 +02:00
20 changed files with 63 additions and 641 deletions

No files matched your search

-8
View File
@@ -1,8 +0,0 @@
.git
.venv
venv
__pycache__
*.pyc
*.db
*.sqlite3
data/
-28
View File
@@ -1,28 +0,0 @@
name: Docker Build & Push
on:
workflow_dispatch:
push:
branches:
- main
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Code auschecken
uses: actions/checkout@v3
- name: Bei Gitea Container Registry anmelden
uses: docker/login-action@v2
with:
registry: ${{ gitea.server_url }}
username: ${{ gitea.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Docker Image bauen und pushen
uses: docker/build-push-action@v4
with:
context: .
push: true
tags: ${{ gitea.server_url }}/${{ gitea.repository }}:latest
+3 -6
View File
@@ -3,18 +3,15 @@ FROM python:3.12-slim
WORKDIR /app
# WICHTIG: Ordner für die SQLite-Datenbank (damit die Daten bei Neustarts nicht gelöscht werden)
RUN mkdir -p /app/data
# Abhängigkeiten installieren
COPY requirements.txt .
RUN pip install --no-cache-dir --upgrade pip && \
pip install --no-cache-dir -r requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
# Deinen Code kopieren
COPY . .
# WICHTIG: Ordner für die SQLite-Datenbank (damit die Daten bei Neustarts nicht gelöscht werden)
RUN mkdir -p /app/data
# Port freigeben
EXPOSE 8000
+7 -49
View File
@@ -1,21 +1,14 @@
# Tandur
# Tandoor-Shoppinglist
Eine Website, die sich von einer selber gehosteten Tandoor-Instanz die Shoppinglist Einträge nimmt, und als Shoppinglist anzeigt.
<div style="border-left: 4px solid #da3633; background-color: rgba(218, 54, 51, 0.1); padding: 12px 16px; border-radius: 0 6px 6px 0; margin: 16px 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;">
<div style="font-weight: 600; color: #f85149; margin-bottom: 4px; display: flex; align-items: center; gap: 8px;">
<span>⚠️</span> <strong>Just created</strong>
</div>
<div style="color: #c9d1d9; font-size: 14px;">
This Repository was just created. It isnt finished and under heavy construction. So this Service is unstable!
</div>
</div>
## Inhalt
- TODO
- Festlegungen
- Ablauf
- Installation
- Fsetlegungen
## TODO
@@ -24,41 +17,6 @@ Eine Website, die sich von einer selber gehosteten Tandoor-Instanz die Shoppingl
- [ ] Next.js -> Frontend ?
- [ ] Python -> Backend
- [ ] Implementieren
- [ ] README in English and German
## Festlegungen
- Database: SQLite3 mit sqlmodel
- API FastAPI
- Jinja
- TailwindCSS + Alpine.js
???
## Ablauf
- Data fetch from Tandoor via APIs
- Data fetch from Database
- View on Website and edit
- Order vie Mail
- CSV download *optional
## Installation
### Bare metal
##### Linux
**Download and Setup**
```
git clone https://git.schamagusa.de/rudi/Tandur.git
cd Tandur
source .venv/bin/activate
#source .venv/bin/activate.fish #if you are using fish-shell
pip install --no-cache-dir -r requirements.txt
```
##### Run
```
uvicorn main:app
```
### Docker Compose (recomended)
#TODO
*Hier muss noch beschrieben werden, wie genau das gemacht wird.*
-33
View File
@@ -1,33 +0,0 @@
from fastapi import Depends, status, Request
from fastapi.security import OAuth2PasswordBearer
import jwt
# auth/dependencies.py
from sqlalchemy.orm import Session
from database import get_db
from models.user import User
from config import settings
from exceptions import UnauthorizedError
def get_me(request: Request, db: Session = Depends(get_db)) -> User:
token = request.cookies.get("access_token")
print(token)
if not token:
raise UnauthorizedError("Token missing")
try:
# 1. Token entschlüsseln
payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
user_id: str = payload.get("sub")
if user_id is None:
raise UnauthorizedError("Token invalid or expired")
except jwt.PyJWTError:
raise UnauthorizedError("Token invalid or expired")
# 2. User aus der Datenbank laden
user = db.get(User, int(user_id))
if user is None:
raise UnauthorizedError("Token invalid or expired")
return user
-23
View File
@@ -1,23 +0,0 @@
from datetime import datetime, timedelta, timezone
import jwt
from pwdlib import PasswordHash
from pwdlib.hashers.argon2 import Argon2Hasher
from config import settings #Settings from .env
password_hash = PasswordHash((Argon2Hasher(),))
def hash_password(password: str) -> str:
return password_hash.hash(password)
def verify_password(plain_password: str, hashed_password: str) -> bool:
return password_hash.verify(plain_password, hashed_password)
def create_access_token(data: dict, expires_delta: timedelta | None = None) -> str:
to_encode = data.copy()
expire = datetime.now(timezone.utc) + (expires_delta or timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES))
to_encode.update({"exp": expire})
return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
-17
View File
@@ -1,17 +0,0 @@
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
# Tandoor Server
API_KEY: str
TANDOOR_URL: str
# Security
SECRET_KEY: str
ALGORITHM: str = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
# Sagt Pydantic, dass es die Werte aus der .env-Datei laden soll
model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
# Instanz erzeugen, die du im gesamten Projekt importierst
settings = Settings()
-79
View File
@@ -1,79 +0,0 @@
# crud/user.py
from sqlalchemy import select, exists, func
from sqlalchemy.orm import Session
from sqlalchemy.exc import IntegrityError
from models.user import User
from exceptions import UserNotFoundError, UserAlreadyExistsError
from auth.security import hash_password
def get_users(db: Session) -> list[User]:
stmt = select(User)
users = db.scalars(stmt).all()
if not users:
raise UserNotFoundError(f"No users in Database")
return users
def get_user_by_id(db: Session, user_id: int) -> User:
stmt = select(User).where(User.id == user_id)
user = db.scalars(stmt).first()
if user is None:
raise UserNotFoundError(f"User with id: {user_id} not found")
return user
def get_user_by_email(db: Session, email: str) -> User:
stmt = select(User).where(func.lower(User.email) == func.lower(email))
user = db.scalars(stmt).first()
if user is None:
raise UserNotFoundError(f"User with email: {email} not found")
return user
def create_user(db: Session, email: str, password: str, role: bool = "user") -> User:
hashed = hash_password(password)
user = User(email=email, password=hashed, role=role)
try:
db.add(user)
db.commit()
db.refresh(user)
return user
except IntegrityError as err:
db.rollback()
raise UserAlreadyExistsError(f"User with email: '{email}' already exists") from err
def update_user(db: Session, user_id: int, user_data: dict) -> User:
user = get_user_by_id(db, user_id)
if not user:
raise UserNotFoundError(f"User with ID {user_id} not found")
# Passwort hashen, falls es im Update enthalten ist
if "password" in user_data and user_data["password"] is not None:
user_data["password"] = hash_password(user_data.pop("password"))
# Nur die mitgeschickten Felder auf dem Objekt setzen
for field, value in user_data.items():
setattr(user, field, value)
try:
db.commit()
db.refresh(user)
return user
except IntegrityError as err:
db.rollback()
raise UserAlreadyExistsError("Email is already in use") from err
def delete_user(db: Session, user_id: int) -> User:
user = get_user_by_id(db, user_id)
if user is None:
raise UserNotFoundError(f"User with id: {user_id} not found")
db.delete(user)
db.commit()
return user
+19 -17
View File
@@ -1,21 +1,23 @@
# database.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base
from typing import Optional
from sqlmodel import Field, SQLModel, create_engine, Session
DATABASE_URL = "sqlite:///./tandur.db" # Datei landet im Projektordner
# 1. Das Datenmodell (Tabelle in der DB)
class ShoppingItem(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
menge: int = Field(default=1)
gekauft: bool = Field(default=False)
engine = create_engine(
DATABASE_URL,
connect_args={"check_same_thread": False} # nötig für SQLite + FastAPI
)
# 2. Die SQLite-Verbindung
# check_same_thread=False ist zwingend nötig für FastAPI + SQLite
sqlite_url = "sqlite:///tandur.db"
engine = create_engine(sqlite_url, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
# 3. Funktion zum Erstellen der Tabellen
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
Base = declarative_base()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
# 4. Session-Generator für die Routen
def get_session():
with Session(engine) as session:
yield session
-79
View File
@@ -1,79 +0,0 @@
from typing import Any
class AppError(Exception):
"""Basisklasse für alle eigenen Fehler dieser App"""
def __init__(self, message: str = "Ein unerwarteter Fehler ist aufgetreten."):
self.message = message
super().__init__(self.message)
# ==========================================
# 1. Datenbank- & Ressourcen-Fehler
# ==========================================
class DatabaseError(AppError):
"""Basisklasse für Datenbank-bezogene Fehler"""
pass
class NotFoundError(DatabaseError):
"""Ein angefragter Datensatz existiert nicht"""
def __init__(self, resource: str = "Ressource", identifier: Any = None):
if identifier:
msg = f"{resource} mit ID/Kennung '{identifier}' wurde nicht gefunden."
else:
msg = f"{resource} wurde nicht gefunden."
super().__init__(msg)
class AlreadyExistsError(DatabaseError):
"""Ein Unique-Constraint wurde verletzt (z. B. doppelte E-Mail)"""
def __init__(self, resource: str = "Ressource", field: str = "Eintrag", value: Any = None):
if value:
msg = f"{resource} mit {field} '{value}' existiert bereits."
else:
msg = f"{resource} existiert bereits."
super().__init__(msg)
# Domänen-spezifische Ressourcen-Fehler
class UserNotFoundError(NotFoundError):
def __init__(self, identifier: Any = None):
super().__init__(resource="User", identifier=identifier)
class UserAlreadyExistsError(AlreadyExistsError):
def __init__(self, field: str = "E-Mail", value: Any = None):
super().__init__(resource="User", field=field, value=value)
# ==========================================
# 2. Authentifizierung & Autorisierung
# ==========================================
class AuthError(AppError):
"""Basisklasse für Authentifizierungs- und Rechte-Fehler"""
pass
class UnauthorizedError(AuthError):
"""Ungültiges Token oder falsche Login-Daten"""
def __init__(self, message: str = "Ungültige Anmeldedaten oder Token abgelaufen."):
super().__init__(message)
class ForbiddenError(AuthError):
"""Fehlende Berechtigungen (z.B. Kein Admin)"""
def __init__(self, message: str = "Unzureichende Berechtigungen für diese Aktion."):
super().__init__(message)
# ==========================================
# 3. Validierungsfehler (Business Logic)
# ==========================================
class ValidationError(AppError):
"""Fehler in der Business-Logik (unabhängig von Pydantic)"""
def __init__(self, message: str = "Ungültige Eingabedaten."):
super().__init__(message)
+13 -51
View File
@@ -1,57 +1,19 @@
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse
from contextlib import asynccontextmanager
from fastapi import FastAPI, Request, Depends
from fastapi.templating import Jinja2Templates
from exceptions import UserNotFoundError, UserAlreadyExistsError, UnauthorizedError, ForbiddenError, ValidationError
import models #Database
from routers import api_router #API
from database import create_db_and_tables, get_session, ShoppingItem
from sqlmodel import Session
app = FastAPI(title="Tandur API")
app.include_router(api_router)
# Wird beim Starten des Servers exakt einmal ausgeführt
@asynccontextmanager
async def lifespan(app: FastAPI):
create_db_and_tables()
yield
app = FastAPI(lifespan=lifespan)
templates = Jinja2Templates(directory="templates")
######### ERROR handling #########
# 1. Globale Regel für 404
@app.exception_handler(UserNotFoundError)
def user_not_found_handler(request: Request, exc: UserNotFoundError):
return JSONResponse(
status_code=status.HTTP_404_NOT_FOUND,
content={"detail": str(exc)},
)
# 2. Globale Regel für 409
@app.exception_handler(UserAlreadyExistsError)
def user_exists_handler(request: Request, exc: UserAlreadyExistsError):
return JSONResponse(
status_code=status.HTTP_409_CONFLICT,
content={"detail": str(exc)},
)
@app.exception_handler(UnauthorizedError)
def unauthorized_handler(request: Request, exc: UnauthorizedError):
return JSONResponse(
status_code=status.HTTP_401_UNAUTHORIZED,
content={"detail": str(exc)},
headers={"WWW-Authenticate": "Bearer"},
)
@app.exception_handler(ForbiddenError)
def permissions_handler(request: Request, exc: ForbiddenError):
return JSONResponse(
status_code=status.HTTP_403_FORBIDDEN,
content={"detail": str(exc)},
)
@app.exception_handler(ValidationError)
def permissions_handler(request: Request, exc: ValidationError):
return JSONResponse(
status_code=status.HTTP_400_BAD_REQUEST,
content={"detail": str(exc)},
)
@app.get("/")
async def home(request: Request):
async def home(request: Request, session: Session = Depends(get_session)):
# Hier können wir bald Daten aus der DB laden
return templates.TemplateResponse(request=request, name="index.html")
-1
View File
@@ -1 +0,0 @@
from .user import User
-12
View File
@@ -1,12 +0,0 @@
from sqlalchemy import Column, Integer, String, Boolean, DateTime
from sqlalchemy.sql import func
from database import Base
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
email = Column(String, unique=True, index=True, nullable=False)
password = Column(String, nullable=False)
role = Column(String, default="user")
created_at = Column(DateTime(timezone=True), server_default=func.now())
+21 -59
View File
@@ -1,59 +1,21 @@
a2wsgi==1.10.10
argon2_cffi_bindings==25.1.0
argon2pure==1.3
bcryptor==1.2.2
boto3==1.43.82
brotli==1.2.0
brotlicffi==1.2.0.2
cffi==2.1.1
chardet==7.6.0
colorama==0.4.6
ConfigParser==7.2.0
cx_Oracle==8.3.0
cython==3.3.0
docutils==0.23
email_validator==2.3.0
eval_type_backport==0.4.0
exceptiongroup==1.3.1
fastapi_cli==0.0.32
fastpbkdf2==0.2
filelock==3.32.4
gunicorn==26.2.0
h2==4.4.1
HTMLParser==0.0.2
httptools==0.8.0
httpx2==2.12.0
hypothesis==6.165.10
importlib_metadata==9.0.0
ipython==9.16.1
ipywidgets==8.1.9
itsdangerous==2.2.0
jnius==1.1.0
js==1.0
keyring==25.7.0
nose==1.3.7
objgraph==3.6.2
outcome==1.3.0.post0
protobuf==7.36.0
psutil==7.2.2
pydantic_extra_types==2.11.1
pyodide==0.0.2
pyOpenSSL==26.4.0
pysqlcipher3==1.2.0
pytest==9.1.1
redis==8.1.0
setuptools==84.0.0
simplejson==4.1.2
sniffio==1.3.1
socksio==1.0.0
Sphinx==9.1.0
sqlcipher3==0.6.2
thread==2.0.6
types_boto3_secretsmanager==1.43.0
unittest2==1.1.0
watchfiles==1.2.0
winloop==0.6.3
wsproto==1.3.2
xmlrpclib==1.0.1
zstandard==0.25.0
zttp==0.0.28
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.14.2
certifi==2026.7.22
click==8.4.2
fastapi==0.141.1
greenlet==3.5.5
h11==0.16.0
httpcore==1.0.9
httpx==0.28.1
idna==3.19
Jinja2==3.1.6
MarkupSafe==3.0.3
pydantic==2.13.4
pydantic_core==2.46.4
SQLAlchemy==2.0.52
sqlmodel==0.0.39
starlette==1.6.0
typing-inspection==0.4.4
typing_extensions==4.16.0
uvicorn==0.52.4
-10
View File
@@ -1,10 +0,0 @@
from fastapi import APIRouter
from .users import router as users_router
from .auth import router as auth_router
api_router = APIRouter()
api_router.include_router(users_router, prefix="/api")
api_router.include_router(auth_router, prefix="/api")
-40
View File
@@ -1,40 +0,0 @@
# routers/auth.py
from fastapi import APIRouter, Depends, status, Response
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.orm import Session
from database import get_db
from schemas.auth import LoginRequest
from schemas.user import UserResponse
#from exceptions import UserAlreadyExistsError, UserNotFoundError
from crud.user import get_user_by_email
from auth.security import verify_password, create_access_token
router = APIRouter(prefix="/auth", tags=["Authentication"])
@router.post("/login", response_model=UserResponse, status_code=status.HTTP_200_OK)
def login(
data: LoginRequest,
response: Response,
db: Session = Depends(get_db)
):
user = get_user_by_email(db, email=data.username)
if not user or not verify_password(data.password, user.password):
raise UnauthorizedError("Wrong username or password")
access_token = create_access_token(data={"sub": str(user.id)})
response.set_cookie(
key="access_token",
value=access_token,
httponly=True, # Schutz gegen XSS
secure=False, # Im local dev (HTTP) auf False, auf Prod (HTTPS) auf True
samesite="lax",
)
return user
-59
View File
@@ -1,59 +0,0 @@
# routers/users.py
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from database import get_db
from schemas.user import UserCreate, UserResponse, UserUpdate
from exceptions import UserAlreadyExistsError, UserNotFoundError, ForbiddenError
from crud.user import get_users, get_user_by_id, get_user_by_email, create_user, update_user, delete_user
from auth.dependencies import get_me
router = APIRouter(prefix="/users", tags=["Users"])
@router.get("/", response_model=list[UserResponse])
def read_users(db: Session = Depends(get_db), me: User = Depends(get_me)):
if(me.role != "admin"):
raise ForbiddenError("Not authorized")
return get_users(db=db)
@router.get("/me", response_model=UserResponse)
def read_me(db: Session = Depends(get_db), me: User = Depends(get_me)):
return me
@router.get("/by-email", response_model=UserResponse)
def read_user_by_email(email: str, db: Session = Depends(get_db), me: User = Depends(get_me)):
return get_user_by_email(db=db, email=email)
@router.get("/{user_id}", response_model=UserResponse)
def read_user(user_id: int, db: Session = Depends(get_db), me: User = Depends(get_me)):
if(user_id != me.id and me.role != "admin"):
raise ForbiddenError("Not authorized")
return get_user_by_id(db=db, user_id=user_id)
@router.post("/", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
def register_user(user_data: UserCreate, db: Session = Depends(get_db), me: User = Depends(get_me)):
if(me.role != "admin"):
raise ForbiddenError("Not authorized")
return create_user(
db=db,
email=user_data.email,
password=user_data.password,
role=user_data.role
)
@router.patch("/{user_id}", response_model=UserResponse, status_code=status.HTTP_200_OK)
def patch_user(user_id: int, user_data: UserUpdate, db: Session = Depends(get_db), me: User = Depends(get_me)):
if(user_id != me.id and me.role != "admin"):
raise ForbiddenError("Not authorized")
update_dict = user_data.model_dump(exclude_unset=True)
return update_user(db=db, user_id=user_id, user_data=update_dict)
@router.delete("/{user_id}", response_model=UserResponse)
def del_user(user_id: int, db: Session = Depends(get_db), me: User = Depends(get_me)):
if(user_id != me.id and me.role != "admin"):
raise ForbiddenError("Not authorized")
return delete_user(db=db, user_id=user_id)
-15
View File
@@ -1,15 +0,0 @@
# /schemas/auth.py
from pydantic import BaseModel
class LoginRequest(BaseModel):
username: str
password: str
class TokenData(BaseModel):
user_id: int | None = None
class AuthResponse(BaseModel):
message: str
-19
View File
@@ -1,19 +0,0 @@
from pydantic import BaseModel
class UserCreate(BaseModel):
email: str
password: str
role: str | None = "user"
class UserUpdate(BaseModel):
email: str | None = None
password: str | None = None
role: str | None = None
class UserResponse(BaseModel):
id: int
email: str
role: str
class Config:
from_attributes = True # Für SQLAlchemy 2.0 Kompatibilität
-36
View File
@@ -1,36 +0,0 @@
# test_db.py (im Projekt-Root, NICHT in app/ falls main.py woanders liegt)
from database import SessionLocal, engine, Base
import models
Base.metadata.create_all(bind=engine) # falls Tabelle noch nicht existiert
from crud.user import create_user, get_user_by_email, update_user, delete_user, verify_password
db = SessionLocal()
# Erstellen
u = create_user(db, email="2test@example.com", password="test1234", role="admin")
print("Erstellt:", u.id, u.email, u.role)
# Lesen
found = get_user_by_email(db, "1test@example.com")
print(found)
print("Gefunden:", found.email if found else "nicht gefunden")
# Passwort prüfen
print("Passwort korrekt:", verify_password("test1234", found.password))
print("Falsches Passwort:", verify_password("falsch", found.password))
# Updaten
updated = update_user(db, u.id, email="neu@example.com")
print("Aktualisiert:", updated.email)
# Löschen
success = delete_user(db, u.id)
print("Gelöscht:", success)
# Prüfen, ob wirklich weg
gone = get_user_by_email(db, "neu@example.com")
print("Nach Löschen noch da?:", gone)
db.close()