Refactoring - Fix2

v2_adminpanel/routes/api_routes.py

@@ -9,12 +9,49 @@ from utils.audit import log_audit
 from utils.network import get_client_ip
 from utils.license import generate_license_key
 from db import get_connection, get_db_connection, get_db_cursor
-from models import get_license_by_id
+from models import get_license_by_id, get_customers
 
 # Create Blueprint
 api_bp = Blueprint('api', __name__, url_prefix='/api')
 
 
+@api_bp.route("/customers", methods=["GET"])
+@login_required
+def api_customers():
+    """API endpoint for customer search (used by Select2)"""
+    search = request.args.get('q', '').strip()
+    page = int(request.args.get('page', 1))
+    per_page = 20
+    
+    try:
+        # Get all customers (with optional search)
+        customers = get_customers(show_test=True, search=search)
+        
+        # Pagination
+        start = (page - 1) * per_page
+        end = start + per_page
+        paginated_customers = customers[start:end]
+        
+        # Format for Select2
+        results = []
+        for customer in paginated_customers:
+            results.append({
+                'id': customer['id'],
+                'text': f"{customer['name']} ({customer['email'] or 'keine E-Mail'})"
+            })
+        
+        return jsonify({
+            'results': results,
+            'pagination': {
+                'more': len(customers) > end
+            }
+        })
+        
+    except Exception as e:
+        logging.error(f"Error in api_customers: {str(e)}")
+        return jsonify({'error': 'Fehler beim Laden der Kunden'}), 500
+
+
 @api_bp.route("/license/<int:license_id>/toggle", methods=["POST"])
 @login_required
 def toggle_license(license_id):
@@ -793,114 +830,4 @@ def api_generate_key():
         }), 500
 
 
-@api_bp.route("/customers", methods=['GET'])
-@login_required
-def api_customers():
-    """API Endpoint für die Kundensuche mit Select2"""
-    try:
-        # Suchparameter
-        search = request.args.get('q', '').strip()
-        page = request.args.get('page', 1, type=int)
-        per_page = 20
-        customer_id = request.args.get('id', type=int)
-        
-        conn = get_connection()
-        cur = conn.cursor()
-        
-        # Einzelnen Kunden per ID abrufen
-        if customer_id:
-            cur.execute("""
-                SELECT c.id, c.name, c.email,
-                       COUNT(l.id) as license_count
-                FROM customers c
-                LEFT JOIN licenses l ON c.id = l.customer_id
-                WHERE c.id = %s
-                GROUP BY c.id, c.name, c.email
-            """, (customer_id,))
-            
-            customer = cur.fetchone()
-            results = []
-            if customer:
-                results.append({
-                    'id': customer[0],
-                    'text': f"{customer[1]} ({customer[2]})",
-                    'name': customer[1],
-                    'email': customer[2],
-                    'license_count': customer[3]
-                })
-            
-            cur.close()
-            conn.close()
-            
-            return jsonify({
-                'results': results,
-                'pagination': {'more': False}
-            })
-        
-        # SQL Query mit optionaler Suche
-        elif search:
-            cur.execute("""
-                SELECT c.id, c.name, c.email,
-                       COUNT(l.id) as license_count
-                FROM customers c
-                LEFT JOIN licenses l ON c.id = l.customer_id
-                WHERE LOWER(c.name) LIKE LOWER(%s)
-                   OR LOWER(c.email) LIKE LOWER(%s)
-                GROUP BY c.id, c.name, c.email
-                ORDER BY c.name
-                LIMIT %s OFFSET %s
-            """, (f'%{search}%', f'%{search}%', per_page, (page - 1) * per_page))
-        else:
-            cur.execute("""
-                SELECT c.id, c.name, c.email,
-                       COUNT(l.id) as license_count
-                FROM customers c
-                LEFT JOIN licenses l ON c.id = l.customer_id
-                GROUP BY c.id, c.name, c.email
-                ORDER BY c.name
-                LIMIT %s OFFSET %s
-            """, (per_page, (page - 1) * per_page))
-        
-        customers = cur.fetchall()
-        
-        # Format für Select2
-        results = []
-        for customer in customers:
-            results.append({
-                'id': customer[0],
-                'text': f"{customer[1]} - {customer[2]} ({customer[3]} Lizenzen)",
-                'name': customer[1],
-                'email': customer[2],
-                'license_count': customer[3]
-            })
-        
-        # Gesamtanzahl für Pagination
-        if search:
-            cur.execute("""
-                SELECT COUNT(*) FROM customers
-                WHERE LOWER(name) LIKE LOWER(%s)
-                   OR LOWER(email) LIKE LOWER(%s)
-            """, (f'%{search}%', f'%{search}%'))
-        else:
-            cur.execute("SELECT COUNT(*) FROM customers")
-        
-        total_count = cur.fetchone()[0]
-        
-        cur.close()
-        conn.close()
-        
-        # Select2 Response Format
-        return jsonify({
-            'results': results,
-            'pagination': {
-                'more': (page * per_page) < total_count
-            }
-        })
-        
-    except Exception as e:
-        logging.error(f"Fehler bei Kundensuche: {str(e)}")
-        return jsonify({
-            'results': [],
-            'pagination': {'more': False},
-            'error': str(e)
-        }), 500
+