manage-your-printer/blueprints/users.py

from flask import Blueprint, render_template, request, jsonify, redirect, url_for, abort
from flask_login import current_user, login_required
from sqlalchemy.exc import SQLAlchemyError
from functools import wraps

from models import User, UserPermission, get_cached_session
from utils.logging_config import get_logger

users_blueprint = Blueprint('users', __name__)
logger = get_logger("users")

def users_admin_required(f):
    """Decorator zur Prüfung der Admin-Berechtigung für Users Blueprint."""
    @wraps(f)
    @login_required
    def users_decorated_function(*args, **kwargs):
        if not current_user.is_admin:
            abort(403, "Nur Administratoren haben Zugriff auf diese Seite")
        return f(*args, **kwargs)
    return users_decorated_function

@users_blueprint.route('/admin/users/<int:user_id>/permissions', methods=['GET'])
@users_admin_required
def admin_user_permissions(user_id):
    """Benutzerberechtigungen anzeigen und bearbeiten."""
    with get_cached_session() as db_session:
        user = db_session.query(User).filter_by(id=user_id).first()
        if not user:
            abort(404, "Benutzer nicht gefunden")
        
        # Berechtigungen laden oder erstellen, falls nicht vorhanden
        permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
        if not permission:
            permission = UserPermission(user_id=user_id)
            db_session.add(permission)
            db_session.commit()
    
    return render_template('admin_user_permissions.html', user=user, permission=permission)

@users_blueprint.route('/api/users/<int:user_id>/permissions', methods=['GET'])
@login_required
def api_get_user_permissions(user_id):
    """Benutzerberechtigungen als JSON zurückgeben."""
    # Nur Admins oder der Benutzer selbst darf seine Berechtigungen sehen
    if not current_user.is_admin and current_user.id != user_id:
        return jsonify({"error": "Keine Berechtigung"}), 403
    
    try:
        with get_cached_session() as db_session:
            permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
            
            if not permission:
                # Falls keine Berechtigungen existieren, Standard-Werte zurückgeben
                return jsonify({
                    "user_id": user_id,
                    "can_start_jobs": False,
                    "needs_approval": True,
                    "can_approve_jobs": False
                })
            
            return jsonify(permission.to_dict())
            
    except Exception as e:
        logger.error(f"Fehler beim Abrufen der Benutzerberechtigungen: {str(e)}")
        return jsonify({"error": "Fehler beim Verarbeiten der Anfrage"}), 500

@users_blueprint.route('/api/users/<int:user_id>/permissions', methods=['PUT'])
@users_admin_required
def api_update_user_permissions(user_id):
    """Benutzerberechtigungen aktualisieren."""
    try:
        data = request.get_json()
        if not data:
            return jsonify({"error": "Keine Daten erhalten"}), 400
        
        with get_cached_session() as db_session:
            # Benutzer prüfen
            user = db_session.query(User).filter_by(id=user_id).first()
            if not user:
                return jsonify({"error": "Benutzer nicht gefunden"}), 404
            
            # Berechtigungen laden oder erstellen
            permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
            if not permission:
                permission = UserPermission(user_id=user_id)
                db_session.add(permission)
            
            # Berechtigungen aktualisieren
            if 'can_start_jobs' in data:
                permission.can_start_jobs = bool(data['can_start_jobs'])
            
            if 'needs_approval' in data:
                permission.needs_approval = bool(data['needs_approval'])
            
            if 'can_approve_jobs' in data:
                permission.can_approve_jobs = bool(data['can_approve_jobs'])
            
            db_session.commit()
            
            logger.info(f"Berechtigungen für Benutzer {user_id} aktualisiert durch Admin {current_user.id}")
            
            return jsonify({
                "success": True,
                "permissions": permission.to_dict()
            })
            
    except SQLAlchemyError as e:
        logger.error(f"Datenbankfehler beim Aktualisieren der Benutzerberechtigungen: {str(e)}")
        return jsonify({"error": "Datenbankfehler beim Verarbeiten der Anfrage"}), 500
    except Exception as e:
        logger.error(f"Fehler beim Aktualisieren der Benutzerberechtigungen: {str(e)}")
        return jsonify({"error": "Fehler beim Verarbeiten der Anfrage"}), 500

@users_blueprint.route('/admin/users/<int:user_id>/permissions/update', methods=['POST'])
@users_admin_required
def admin_update_user_permissions(user_id):
    """Benutzerberechtigungen über Formular aktualisieren."""
    try:
        # Formularfelder auslesen
        can_start_jobs = request.form.get('can_start_jobs') == 'on'
        needs_approval = request.form.get('needs_approval') == 'on'
        can_approve_jobs = request.form.get('can_approve_jobs') == 'on'
        
        with get_cached_session() as db_session:
            # Benutzer prüfen
            user = db_session.query(User).filter_by(id=user_id).first()
            if not user:
                abort(404, "Benutzer nicht gefunden")
            
            # Berechtigungen laden oder erstellen
            permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
            if not permission:
                permission = UserPermission(user_id=user_id)
                db_session.add(permission)
            
            # Berechtigungen aktualisieren
            permission.can_start_jobs = can_start_jobs
            permission.needs_approval = needs_approval
            permission.can_approve_jobs = can_approve_jobs
            
            db_session.commit()
            
            logger.info(f"Berechtigungen für Benutzer {user_id} aktualisiert durch Admin {current_user.id} (Formular)")
            
            return redirect(url_for('users.admin_user_permissions', user_id=user_id))
            
    except Exception as e:
        logger.error(f"Fehler beim Aktualisieren der Benutzerberechtigungen: {str(e)}")
        abort(500, "Fehler beim Verarbeiten der Anfrage")

# Erweiterung des bestehenden Benutzer-Bearbeitungsformulars
@users_blueprint.route('/admin/users/<int:user_id>/edit/permissions', methods=['GET'])
@users_admin_required
def admin_edit_user_permissions_section(user_id):
    """Rendert nur den Berechtigungsteil für das Benutzer-Edit-Formular."""
    with get_cached_session() as db_session:
        user = db_session.query(User).filter_by(id=user_id).first()
        if not user:
            abort(404, "Benutzer nicht gefunden")
        
        # Berechtigungen laden oder erstellen, falls nicht vorhanden
        permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
        if not permission:
            permission = UserPermission(user_id=user_id)
            db_session.add(permission)
            db_session.commit()
    
    return render_template('_user_permissions_form.html', user=user, permission=permission)