QueryBuilder/app/routes/main.py

from flask import Blueprint, render_template, request, redirect, url_for, flash, jsonify
from flask_login import login_required, current_user
from app.models import SavedQuery, DatabaseConnection
from app.services.database_service import DatabaseService
from app.services.database_manager import DatabaseManager
from app import db
import traceback

main_bp = Blueprint('main', __name__)

@main_bp.route('/')
@login_required
def dashboard():
    # Lade gespeicherte Queries des Benutzers
    saved_queries = SavedQuery.query.filter_by(user_id=current_user.id).all()
    
    # Lade verfügbare Datenbankverbindungen
    db_manager = DatabaseManager()
    available_connections = db_manager.get_available_connections()
    
    return render_template('dashboard.html', 
                         saved_queries=saved_queries,
                         available_connections=available_connections)

@main_bp.route('/execute_query', methods=['POST'])
@login_required
def execute_query():
    data = request.get_json()
    query = data.get('query', '').strip()
    connection = data.get('connection', 'oracle')  # Standard: Oracle
    
    if not query:
        return jsonify({'error': 'Query ist leer'}), 400
    
    try:
        # Verwende ausgewählte Datenbankverbindung
        db_manager = DatabaseManager()
        db_service = db_manager.get_database_service(connection)
        results = db_service.execute_query(query)
        
        return jsonify({
            'success': True,
            'results': results,
            'connection': connection
        })
        
    except Exception as e:
        return jsonify({
            'error': f'Fehler beim Ausführen der Query: {str(e)}',
            'traceback': traceback.format_exc()
        }), 500

@main_bp.route('/get_tables')
@login_required
def get_tables():
    connection = request.args.get('connection', 'oracle')
    
    try:
        db_manager = DatabaseManager()
        db_service = db_manager.get_database_service(connection)
        tables = db_service.get_tables()
        
        return jsonify({
            'success': True,
            'tables': tables,
            'connection': connection
        })
        
    except Exception as e:
        return jsonify({
            'error': f'Fehler beim Laden der Tabellen: {str(e)}'
        }), 500

@main_bp.route('/get_table_schema/<table_name>')
@login_required
def get_table_schema(table_name):
    connection = request.args.get('connection', 'oracle')
    
    try:
        db_manager = DatabaseManager()
        db_service = db_manager.get_database_service(connection)
        schema = db_service.get_table_schema(table_name)
        
        return jsonify({
            'success': True,
            'schema': schema,
            'connection': connection
        })
        
    except Exception as e:
        return jsonify({
            'error': f'Fehler beim Laden des Tabellenschemas: {str(e)}'
        }), 500

@main_bp.route('/save_query', methods=['POST'])
@login_required
def save_query():
    data = request.get_json()
    name = data.get('name', '').strip()
    description = data.get('description', '').strip()
    query = data.get('query', '').strip()
    
    if not name or not query:
        return jsonify({'error': 'Name und Query sind erforderlich'}), 400
    
    # Prüfe ob Query-Name bereits existiert
    existing = SavedQuery.query.filter_by(name=name, user_id=current_user.id).first()
    if existing:
        return jsonify({'error': 'Query-Name bereits vergeben'}), 400
    
    try:
        saved_query = SavedQuery(
            name=name,
            description=description,
            query_text=query,
            user_id=current_user.id
        )
        
        db.session.add(saved_query)
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': 'Query erfolgreich gespeichert',
            'query': saved_query.to_dict()
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': f'Fehler beim Speichern: {str(e)}'}), 500

@main_bp.route('/delete_query/<int:query_id>', methods=['DELETE'])
@login_required
def delete_query(query_id):
    try:
        query = SavedQuery.query.filter_by(id=query_id, user_id=current_user.id).first()
        if not query:
            return jsonify({'error': 'Query nicht gefunden'}), 404
        
        db.session.delete(query)
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': 'Query erfolgreich gelöscht'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': f'Fehler beim Löschen: {str(e)}'}), 500

@main_bp.route('/test_connection/<connection_name>')
@login_required
def test_connection(connection_name):
    try:
        db_manager = DatabaseManager()
        result = db_manager.test_connection(connection_name)
        
        return jsonify(result)
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'Fehler beim Testen der Verbindung: {str(e)}'
        }), 500

@main_bp.route('/get_connections')
@login_required
def get_connections():
    try:
        db_manager = DatabaseManager()
        connections = db_manager.get_available_connections()
        
        return jsonify({
            'success': True,
            'connections': connections
        })
        
    except Exception as e:
        return jsonify({
            'error': f'Fehler beim Laden der Verbindungen: {str(e)}'
        }), 500