# Installation: pip install flask

from flask import Flask, render_template, request, jsonify

app = Flask(__name__)

# Einfache Route
@app.route('/')
def home():
    return '
Willkommen bei Bold Haze Python Kursen!
'

# Route mit Parameter
@app.route('/kurs/<kurs_name>')
def kurs_details(kurs_name):
    kurse = {
        'python-basics': 'Python Grundlagen - 8 Wochen',
        'data-science': 'Data Science mit Python - 12 Wochen',
        'web-dev': 'Web-Entwicklung mit Flask - 10 Wochen'
    }
    
    if kurs_name in kurse:
        return f'
{kurse[kurs_name]}
'
    else:
        return '
Kurs nicht gefunden
', 404

# JSON API Endpoint
@app.route('/api/kurse')
def api_kurse():
    kurse_data = [
        {'id': 1, 'name': 'Python Grundlagen', 'preis': 299, 'dauer': '8 Wochen'},
        {'id': 2, 'name': 'Data Science', 'preis': 599, 'dauer': '12 Wochen'},
        {'id': 3, 'name': 'Web-Entwicklung', 'preis': 449, 'dauer': '10 Wochen'}
    ]
    return jsonify(kurse_data)

# POST Request verarbeiten
@app.route('/anmeldung', methods=['GET', 'POST'])
def anmeldung():
    if request.method == 'POST':
        name = request.form['name']
        email = request.form['email']
        kurs = request.form['kurs']
        
        # Hier würde die Anmeldung verarbeitet werden
        return f'Danke {name}! Anmeldung für {kurs} erhalten.'
    
    # GET Request - Formular anzeigen
    return '''
    

        Name: 

        Email: 

        Kurs: 
            Python Grundlagen
            Data Science
            Web-Entwicklung
        

        
    
    '''

if __name__ == '__main__':
    app.run(debug=True)

# app.py - Erweiterte Flask App
from flask import Flask, render_template, Blueprint

app = Flask(__name__)

# Blueprint für Kurs-bezogene Routen
kurse_bp = Blueprint('kurse', __name__, url_prefix='/kurse')

@kurse_bp.route('/')
def kurs_liste():
    kurse = [
        {'name': 'Python Grundlagen', 'beschreibung': 'Perfekt für Einsteiger'},
        {'name': 'Data Science', 'beschreibung': 'Datenanalyse mit Python'},
        {'name': 'Web-Entwicklung', 'beschreibung': 'Moderne Webanwendungen'}
    ]
    return render_template('kurse.html', kurse=kurse)

@kurse_bp.route('/<int:kurs_id>')
def kurs_detail(kurs_id):
    # Dummy-Daten für Demo
    kurs = {
        'id': kurs_id,
        'name': 'Python Grundlagen',
        'beschreibung': 'Lernen Sie Python von Grund auf',
        'preis': 299,
        'dauer': '8 Wochen'
    }
    return render_template('kurs_detail.html', kurs=kurs)

# Blueprint registrieren
app.register_blueprint(kurse_bp)

@app.route('/')
def home():
    return render_template('home.html')

# Templates (würden in templates/ Ordner gespeichert):
# templates/base.html
base_template = '''



    
    


    
    

        {% block content %}{% endblock %}
    


'''

# templates/kurse.html
kurse_template = '''
{% extends "base.html" %}
{% block title %}Unsere Kurse{% endblock %}
{% block content %}
    
Unsere Python Kurse
    {% for kurs in kurse %}
        

            
{{ kurs.name }}
            
{{ kurs.beschreibung }}
            Details
        
    {% endfor %}
{% endblock %}
'''

# Installation: pip install django

# Neues Projekt erstellen
# django-admin startproject bold_haze_academy
# cd bold_haze_academy
# python manage.py startapp kurse

# models.py - Datenmodelle definieren
from django.db import models
from django.contrib.auth.models import User

class Kategorie(models.Model):
    name = models.CharField(max_length=100)
    beschreibung = models.TextField()
    
    def __str__(self):
        return self.name

class Kurs(models.Model):
    SCHWIERIGKEIT_CHOICES = [
        ('anfaenger', 'Anfänger'),
        ('fortgeschritten', 'Fortgeschritten'),
        ('experte', 'Experte'),
    ]
    
    titel = models.CharField(max_length=200)
    beschreibung = models.TextField()
    kategorie = models.ForeignKey(Kategorie, on_delete=models.CASCADE)
    preis = models.DecimalField(max_digits=8, decimal_places=2)
    dauer_wochen = models.IntegerField()
    schwierigkeit = models.CharField(max_length=20, choices=SCHWIERIGKEIT_CHOICES)
    erstellt_am = models.DateTimeField(auto_now_add=True)
    aktualisiert_am = models.DateTimeField(auto_now=True)
    ist_aktiv = models.BooleanField(default=True)
    
    class Meta:
        ordering = ['-erstellt_am']
    
    def __str__(self):
        return self.titel

class Anmeldung(models.Model):
    kurs = models.ForeignKey(Kurs, on_delete=models.CASCADE)
    benutzer = models.ForeignKey(User, on_delete=models.CASCADE)
    anmelde_datum = models.DateTimeField(auto_now_add=True)
    abgeschlossen = models.BooleanField(default=False)
    note = models.DecimalField(max_digits=3, decimal_places=1, null=True, blank=True)
    
    class Meta:
        unique_together = ['kurs', 'benutzer']
    
    def __str__(self):
        return f'{self.benutzer.username} - {self.kurs.titel}'

# views.py - View-Logic
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse
from django.views.generic import ListView, DetailView
from django.contrib.auth.decorators import login_required
from .models import Kurs, Kategorie, Anmeldung

# Function-based Views
def kurs_liste(request):
    kategorie_filter = request.GET.get('kategorie')
    kurse = Kurs.objects.filter(ist_aktiv=True)
    
    if kategorie_filter:
        kurse = kurse.filter(kategorie__name=kategorie_filter)
    
    kategorien = Kategorie.objects.all()
    
    context = {
        'kurse': kurse,
        'kategorien': kategorien,
        'aktive_kategorie': kategorie_filter
    }
    return render(request, 'kurse/liste.html', context)

def kurs_detail(request, kurs_id):
    kurs = get_object_or_404(Kurs, id=kurs_id, ist_aktiv=True)
    
    # Prüfen ob User bereits angemeldet ist
    ist_angemeldet = False
    if request.user.is_authenticated:
        ist_angemeldet = Anmeldung.objects.filter(
            kurs=kurs, 
            benutzer=request.user
        ).exists()
    
    context = {
        'kurs': kurs,
        'ist_angemeldet': ist_angemeldet
    }
    return render(request, 'kurse/detail.html', context)

# Class-based Views
class KursListView(ListView):
    model = Kurs
    template_name = 'kurse/liste.html'
    context_object_name = 'kurse'
    paginate_by = 6
    
    def get_queryset(self):
        return Kurs.objects.filter(ist_aktiv=True)
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['kategorien'] = Kategorie.objects.all()
        return context

class KursDetailView(DetailView):
    model = Kurs
    template_name = 'kurse/detail.html'
    context_object_name = 'kurs'

# API Views
@login_required
def kurs_anmelden(request, kurs_id):
    if request.method == 'POST':
        kurs = get_object_or_404(Kurs, id=kurs_id)
        anmeldung, created = Anmeldung.objects.get_or_create(
            kurs=kurs,
            benutzer=request.user
        )
        
        if created:
            return JsonResponse({
                'success': True,
                'message': f'Erfolgreich für {kurs.titel} angemeldet!'
            })
        else:
            return JsonResponse({
                'success': False,
                'message': 'Sie sind bereits für diesen Kurs angemeldet.'
            })
    
    return JsonResponse({'success': False, 'message': 'Ungültige Anfrage'})

# urls.py - URL Configuration
from django.urls import path
from . import views

app_name = 'kurse'

urlpatterns = [
    path('', views.KursListView.as_view(), name='liste'),
    path('<int:pk>/', views.KursDetailView.as_view(), name='detail'),
    path('anmelden/<int:kurs_id>/', views.kurs_anmelden, name='anmelden'),
]

# forms.py - Django Forms
from django import forms
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from .models import Anmeldung

class KursAnmeldungForm(forms.ModelForm):
    class Meta:
        model = Anmeldung
        fields = ['kurs']
        widgets = {
            'kurs': forms.Select(attrs={'class': 'form-control'})
        }

class BenutzerRegistrierungForm(UserCreationForm):
    email = forms.EmailField(required=True)
    first_name = forms.CharField(max_length=30, required=True)
    last_name = forms.CharField(max_length=30, required=True)
    
    class Meta:
        model = User
        fields = ('username', 'first_name', 'last_name', 'email', 'password1', 'password2')
    
    def save(self, commit=True):
        user = super().save(commit=False)
        user.email = self.cleaned_data['email']
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        if commit:
            user.save()
        return user

# templates/kurse/liste.html
liste_template = '''
{% extends 'base.html' %}
{% load static %}

{% block title %}Unsere Python Kurse{% endblock %}

{% block content %}

    
Unsere Python Kurse
    
    
    

        Alle
        {% for kategorie in kategorien %}
            
                {{ kategorie.name }}
            
        {% endfor %}
    
    
    
    

        {% for kurs in kurse %}
            

                
{{ kurs.titel }}
                
{{ kurs.kategorie.name }}
                
{{ kurs.beschreibung|truncatewords:20 }}
                

                    {{ kurs.preis }}€
                    {{ kurs.dauer_wochen }} Wochen
                    
                        {{ kurs.get_schwierigkeit_display }}
                    
                
                
                    Details ansehen
                
            
        {% empty %}
            
Keine Kurse verfügbar.
        {% endfor %}
    
    
    
    {% if is_paginated %}
        

            {% if page_obj.has_previous %}
                « Vorherige
            {% endif %}
            
            
                Seite {{ page_obj.number }} von {{ page_obj.paginator.num_pages }}
            
            
            {% if page_obj.has_next %}
                Nächste »
            {% endif %}
        
    {% endif %}

{% endblock %}
'''

# admin.py - Django Admin Interface
from django.contrib import admin
from .models import Kategorie, Kurs, Anmeldung

@admin.register(Kategorie)
class KategorieAdmin(admin.ModelAdmin):
    list_display = ['name', 'beschreibung']
    search_fields = ['name']

@admin.register(Kurs)
class KursAdmin(admin.ModelAdmin):
    list_display = ['titel', 'kategorie', 'preis', 'dauer_wochen', 'schwierigkeit', 'ist_aktiv']
    list_filter = ['kategorie', 'schwierigkeit', 'ist_aktiv', 'erstellt_am']
    search_fields = ['titel', 'beschreibung']
    list_editable = ['ist_aktiv']
    date_hierarchy = 'erstellt_am'
    
    fieldsets = (
        ('Grundinformationen', {
            'fields': ('titel', 'beschreibung', 'kategorie')
        }),
        ('Kursdetails', {
            'fields': ('preis', 'dauer_wochen', 'schwierigkeit')
        }),
        ('Status', {
            'fields': ('ist_aktiv',)
        }),
    )

@admin.register(Anmeldung)
class AnmeldungAdmin(admin.ModelAdmin):
    list_display = ['benutzer', 'kurs', 'anmelde_datum', 'abgeschlossen', 'note']
    list_filter = ['abgeschlossen', 'anmelde_datum', 'kurs__kategorie']
    search_fields = ['benutzer__username', 'benutzer__email', 'kurs__titel']
    date_hierarchy = 'anmelde_datum'
    
    def get_queryset(self, request):
        return super().get_queryset(request).select_related('benutzer', 'kurs')

# Management Commands
# management/commands/import_kurse.py
from django.core.management.base import BaseCommand
from kurse.models import Kategorie, Kurs

class Command(BaseCommand):
    help = 'Importiert Standard-Kurse in die Datenbank'
    
    def handle(self, *args, **options):
        # Kategorien erstellen
        kategorien = [
            {'name': 'Grundlagen', 'beschreibung': 'Einsteiger-Kurse'},
            {'name': 'Data Science', 'beschreibung': 'Datenanalyse und ML'},
            {'name': 'Web-Entwicklung', 'beschreibung': 'Webanwendungen'}
        ]
        
        for kat_data in kategorien:
            kategorie, created = Kategorie.objects.get_or_create(**kat_data)
            if created:
                self.stdout.write(f'Kategorie "{kategorie.name}" erstellt')
        
        # Kurse erstellen
        grundlagen_kat = Kategorie.objects.get(name='Grundlagen')
        
        kurse = [
            {
                'titel': 'Python Grundlagen',
                'beschreibung': 'Lernen Sie Python von Grund auf',
                'kategorie': grundlagen_kat,
                'preis': 299.00,
                'dauer_wochen': 8,
                'schwierigkeit': 'anfaenger'
            }
        ]
        
        for kurs_data in kurse:
            kurs, created = Kurs.objects.get_or_create(**kurs_data)
            if created:
                self.stdout.write(f'Kurs "{kurs.titel}" erstellt')
        
        self.stdout.write(self.style.SUCCESS('Import abgeschlossen!'))

# Installation: pip install fastapi uvicorn python-multipart

from fastapi import FastAPI, HTTPException, Depends, Form
from pydantic import BaseModel, EmailStr
from typing import List, Optional
from datetime import datetime
import uvicorn

app = FastAPI(
    title="Bold Haze Kurs API",
    description="API für Python Kursverwaltung",
    version="1.0.0"
)

# Pydantic Models für Request/Response
class KursBase(BaseModel):
    titel: str
    beschreibung: str
    preis: float
    dauer_wochen: int
    schwierigkeit: str

class KursCreate(KursBase):
    pass

class Kurs(KursBase):
    id: int
    erstellt_am: datetime
    ist_aktiv: bool
    
    class Config:
        orm_mode = True

class BenutzerCreate(BaseModel):
    username: str
    email: EmailStr
    vollname: str

class Benutzer(BaseModel):
    id: int
    username: str
    email: str
    vollname: str
    erstellt_am: datetime

class AnmeldungCreate(BaseModel):
    kurs_id: int

class Anmeldung(BaseModel):
    id: int
    kurs: Kurs
    benutzer: Benutzer
    anmelde_datum: datetime
    abgeschlossen: bool = False

# Dummy-Datenbank (in der Realität würde man SQLAlchemy verwenden)
fake_kurse_db = [
    {
        "id": 1,
        "titel": "Python Grundlagen",
        "beschreibung": "Lernen Sie Python von Grund auf",
        "preis": 299.0,
        "dauer_wochen": 8,
        "schwierigkeit": "anfaenger",
        "erstellt_am": datetime.now(),
        "ist_aktiv": True
    },
    {
        "id": 2,
        "titel": "Data Science mit Python",
        "beschreibung": "Datenanalyse mit Pandas und NumPy",
        "preis": 599.0,
        "dauer_wochen": 12,
        "schwierigkeit": "fortgeschritten",
        "erstellt_am": datetime.now(),
        "ist_aktiv": True
    }
]

# API Endpoints
@app.get("/", tags=["Home"])
async def root():
    return {"message": "Willkommen bei der Bold Haze Kurs API"}

@app.get("/kurse/", response_model=List[Kurs], tags=["Kurse"])
async def get_kurse(
    skip: int = 0,
    limit: int = 10,
    schwierigkeit: Optional[str] = None
):
    """
    Alle Kurse abrufen mit optionalen Filtern
    
    - **skip**: Anzahl zu überspringender Kurse (für Pagination)
    - **limit**: Maximale Anzahl zurückzugebender Kurse
    - **schwierigkeit**: Filter nach Schwierigkeit (anfaenger, fortgeschritten, experte)
    """
    kurse = fake_kurse_db[skip:skip+limit]
    
    if schwierigkeit:
        kurse = [k for k in kurse if k["schwierigkeit"] == schwierigkeit]
    
    return kurse

@app.get("/kurse/{kurs_id}", response_model=Kurs, tags=["Kurse"])
async def get_kurs(kurs_id: int):
    """Einzelnen Kurs nach ID abrufen"""
    kurs = next((k for k in fake_kurse_db if k["id"] == kurs_id), None)
    if not kurs:
        raise HTTPException(status_code=404, detail="Kurs nicht gefunden")
    return kurs

@app.post("/kurse/", response_model=Kurs, tags=["Kurse"])
async def create_kurs(kurs: KursCreate):
    """Neuen Kurs erstellen"""
    new_id = max([k["id"] for k in fake_kurse_db]) + 1
    new_kurs = {
        "id": new_id,
        **kurs.dict(),
        "erstellt_am": datetime.now(),
        "ist_aktiv": True
    }
    fake_kurse_db.append(new_kurs)
    return new_kurs

@app.put("/kurse/{kurs_id}", response_model=Kurs, tags=["Kurse"])
async def update_kurs(kurs_id: int, kurs_update: KursCreate):
    """Kurs aktualisieren"""
    for i, kurs in enumerate(fake_kurse_db):
        if kurs["id"] == kurs_id:
            fake_kurse_db[i].update(kurs_update.dict())
            return fake_kurse_db[i]
    raise HTTPException(status_code=404, detail="Kurs nicht gefunden")

@app.delete("/kurse/{kurs_id}", tags=["Kurse"])
async def delete_kurs(kurs_id: int):
    """Kurs löschen"""
    for i, kurs in enumerate(fake_kurse_db):
        if kurs["id"] == kurs_id:
            del fake_kurse_db[i]
            return {"message": "Kurs erfolgreich gelöscht"}
    raise HTTPException(status_code=404, detail="Kurs nicht gefunden")

# Server starten
if __name__ == "__main__":
    uvicorn.run(
        "main:app", 
        host="0.0.0.0", 
        port=8000, 
        reload=True,
        log_level="info"
    )

# database.py - Datenbankverbindung
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./kurse.db"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL, 
    connect_args={"check_same_thread": False}
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# models.py - SQLAlchemy Models
from sqlalchemy import Boolean, Column, Integer, String, Float, DateTime, ForeignKey
from sqlalchemy.relationship import relationship
from datetime import datetime
from .database import Base

class KursDB(Base):
    __tablename__ = "kurse"
    
    id = Column(Integer, primary_key=True, index=True)
    titel = Column(String, index=True)
    beschreibung = Column(String)
    preis = Column(Float)
    dauer_wochen = Column(Integer)
    schwierigkeit = Column(String)
    erstellt_am = Column(DateTime, default=datetime.utcnow)
    ist_aktiv = Column(Boolean, default=True)
    
    anmeldungen = relationship("AnmeldungDB", back_populates="kurs")

class BenutzerDB(Base):
    __tablename__ = "benutzer"
    
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True, index=True)
    vollname = Column(String)
    erstellt_am = Column(DateTime, default=datetime.utcnow)
    
    anmeldungen = relationship("AnmeldungDB", back_populates="benutzer")

class AnmeldungDB(Base):
    __tablename__ = "anmeldungen"
    
    id = Column(Integer, primary_key=True, index=True)
    kurs_id = Column(Integer, ForeignKey("kurse.id"))
    benutzer_id = Column(Integer, ForeignKey("benutzer.id"))
    anmelde_datum = Column(DateTime, default=datetime.utcnow)
    abgeschlossen = Column(Boolean, default=False)
    
    kurs = relationship("KursDB", back_populates="anmeldungen")
    benutzer = relationship("BenutzerDB", back_populates="anmeldungen")

# crud.py - CRUD Operationen
from sqlalchemy.orm import Session
from . import models, schemas

def get_kurs(db: Session, kurs_id: int):
    return db.query(models.KursDB).filter(models.KursDB.id == kurs_id).first()

def get_kurse(db: Session, skip: int = 0, limit: int = 100):
    return db.query(models.KursDB).offset(skip).limit(limit).all()

def create_kurs(db: Session, kurs: schemas.KursCreate):
    db_kurs = models.KursDB(**kurs.dict())
    db.add(db_kurs)
    db.commit()
    db.refresh(db_kurs)
    return db_kurs

def create_benutzer(db: Session, benutzer: schemas.BenutzerCreate):
    db_benutzer = models.BenutzerDB(**benutzer.dict())
    db.add(db_benutzer)
    db.commit()
    db.refresh(db_benutzer)
    return db_benutzer

# Dependency Injection für Datenbankverbindung
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# Erweiterte API mit echter Datenbank
@app.get("/api/kurse/", response_model=List[schemas.Kurs])
def read_kurse(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    kurse = crud.get_kurse(db, skip=skip, limit=limit)
    return kurse

@app.post("/api/kurse/", response_model=schemas.Kurs)
def create_new_kurs(kurs: schemas.KursCreate, db: Session = Depends(get_db)):
    return crud.create_kurs(db=db, kurs=kurs)

@app.get("/api/kurse/{kurs_id}", response_model=schemas.Kurs)
def read_kurs(kurs_id: int, db: Session = Depends(get_db)):
    kurs = crud.get_kurs(db, kurs_id=kurs_id)
    if kurs is None:
        raise HTTPException(status_code=404, detail="Kurs nicht gefunden")
    return kurs