QueryBuilder/app/routes/api.py

from flask import Blueprint, jsonify, request, make_response
from flask_login import login_required, current_user
from app.models import SavedQuery, db
from app.services.database_service import DatabaseService
from app.services.database_manager import DatabaseManager
import csv
import io
import json

api_bp = Blueprint('api', __name__)

@api_bp.route('/queries', methods=['GET'])
@login_required
def get_saved_queries():
    """API-Endpunkt um alle gespeicherten Queries zu erhalten"""
    try:
        queries = SavedQuery.query.filter_by(user_id=current_user.id).all()
        return jsonify({
            'success': True,
            'queries': [query.to_dict() for query in queries]
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@api_bp.route('/queries/<query_name>', methods=['GET'])
@login_required
def get_query_by_name(query_name):
    """API-Endpunkt um eine gespeicherte Query nach Namen zu erhalten"""
    try:
        query = SavedQuery.query.filter_by(name=query_name, user_id=current_user.id).first()
        if not query:
            return jsonify({'error': 'Query nicht gefunden'}), 404
        
        return jsonify({
            'success': True,
            'query': query.to_dict()
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@api_bp.route('/queries/<query_name>/execute', methods=['GET'])
@login_required
def execute_saved_query(query_name):
    """API-Endpunkt um eine gespeicherte Query auszuführen und Ergebnisse zu erhalten"""
    try:
        # Finde gespeicherte Query
        saved_query = SavedQuery.query.filter_by(name=query_name, user_id=current_user.id).first()
        if not saved_query:
            return jsonify({'error': 'Query nicht gefunden'}), 404
        
        # Datenbankverbindung bestimmen
        connection = request.args.get('connection', 'oracle')
        
        # Führe Query aus
        db_manager = DatabaseManager()
        db_service = db_manager.get_database_service(connection)
        results = db_service.execute_query(saved_query.query_text)
        
        # Format bestimmen (JSON oder CSV)
        format_type = request.args.get('format', 'json').lower()
        
        if format_type == 'csv':
            return export_results_as_csv(results, query_name)
        else:
            return jsonify({
                'success': True,
                'query_name': query_name,
                'results': results
            })
            
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@api_bp.route('/queries/<query_name>/export/csv', methods=['GET'])
@login_required
def export_query_results_csv(query_name):
    """Exportiere Query-Ergebnisse als CSV"""
    try:
        # Finde gespeicherte Query
        saved_query = SavedQuery.query.filter_by(name=query_name, user_id=current_user.id).first()
        if not saved_query:
            return jsonify({'error': 'Query nicht gefunden'}), 404
        
        # Datenbankverbindung bestimmen
        connection = request.args.get('connection', 'oracle')
        
        # Führe Query aus
        db_manager = DatabaseManager()
        db_service = db_manager.get_database_service(connection)
        results = db_service.execute_query(saved_query.query_text)
        
        return export_results_as_csv(results, query_name)
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@api_bp.route('/queries/<query_name>/export/json', methods=['GET'])
@login_required
def export_query_results_json(query_name):
    """Exportiere Query-Ergebnisse als JSON"""
    try:
        # Finde gespeicherte Query
        saved_query = SavedQuery.query.filter_by(name=query_name, user_id=current_user.id).first()
        if not saved_query:
            return jsonify({'error': 'Query nicht gefunden'}), 404
        
        # Datenbankverbindung bestimmen
        connection = request.args.get('connection', 'oracle')
        
        # Führe Query aus
        db_manager = DatabaseManager()
        db_service = db_manager.get_database_service(connection)
        results = db_service.execute_query(saved_query.query_text)
        
        # Erstelle JSON-Response mit Download-Header
        response = make_response(json.dumps({
            'query_name': query_name,
            'results': results
        }, indent=2))
        
        response.headers['Content-Type'] = 'application/json'
        response.headers['Content-Disposition'] = f'attachment; filename="{query_name}_results.json"'
        
        return response
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@api_bp.route('/update_query_name/<int:query_id>', methods=['PUT'])
@login_required
def update_query_name(query_id):
    """API-Endpunkt um den Namen einer gespeicherten Query zu aktualisieren"""
    try:
        data = request.get_json()
        new_name = data.get('name', '').strip()
        
        if not new_name:
            return jsonify({'error': 'Name ist erforderlich'}), 400
        
        # Finde Query
        query = SavedQuery.query.filter_by(id=query_id, user_id=current_user.id).first()
        if not query:
            return jsonify({'error': 'Query nicht gefunden'}), 404
        
        # Prüfe ob Name bereits existiert
        existing_query = SavedQuery.query.filter_by(name=new_name, user_id=current_user.id).first()
        if existing_query and existing_query.id != query_id:
            return jsonify({'error': 'Eine Query mit diesem Namen existiert bereits'}), 400
        
        # Update Name
        query.name = new_name
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': 'Query-Name erfolgreich aktualisiert',
            'query': query.to_dict()
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({'error': str(e)}), 500

def export_results_as_csv(results, filename):
    """Hilfsfunktion um Ergebnisse als CSV zu exportieren"""
    if not results or 'data' not in results or not results['data']:
        return jsonify({'error': 'Keine Daten zum Exportieren'}), 400
    
    # Erstelle CSV
    output = io.StringIO()
    
    # Headers schreiben
    if results['columns']:
        writer = csv.writer(output)
        writer.writerow(results['columns'])
        
        # Daten schreiben
        for row in results['data']:
            writer.writerow(row)
    
    # Response erstellen
    response = make_response(output.getvalue())
    response.headers['Content-Type'] = 'text/csv'
    response.headers['Content-Disposition'] = f'attachment; filename="{filename}_results.csv"'
    
    return response