Batch Lizenzen funktionieren wieder

v2_adminpanel/routes/api_routes.py

@@ -649,33 +649,121 @@ def allocate_resources():
 @login_required
 def check_resource_availability():
     """Prüfe Verfügbarkeit von Ressourcen"""
+    # Einzelne Ressource prüfen (alte API)
     resource_type = request.args.get('type')
+    if resource_type:
         count = int(request.args.get('count', 1))
         is_test = request.args.get('is_test', 'false') == 'true'
-    
+        show_test = request.args.get('show_test', 'false') == 'true'
-    if not resource_type:
-        return jsonify({'error': 'Ressourcen-Typ erforderlich'}), 400
         
         conn = get_connection()
         cur = conn.cursor()
         
         try:
-        # Zähle verfügbare Ressourcen
+            # Hole verfügbare Ressourcen mit Details
+            if show_test:
+                # Zeige alle verfügbaren Ressourcen (Test und Produktion)
                 cur.execute("""
-            SELECT COUNT(*) 
+                    SELECT id, resource_value, is_test
                     FROM resource_pools 
                     WHERE resource_type = %s 
                     AND status = 'available'
-            AND is_test = %s
+                    ORDER BY is_test, resource_value
-        """, (resource_type, is_test))
+                    LIMIT %s
+                """, (resource_type, count))
+            else:
+                # Zeige nur Produktions-Ressourcen
+                cur.execute("""
+                    SELECT id, resource_value, is_test
+                    FROM resource_pools 
+                    WHERE resource_type = %s 
+                    AND status = 'available' 
+                    AND is_test = false
+                    ORDER BY resource_value
+                    LIMIT %s
+                """, (resource_type, count))
             
-        available_count = cur.fetchone()[0]
+            available_resources = []
+            for row in cur.fetchall():
+                available_resources.append({
+                    'id': row[0],
+                    'value': row[1],
+                    'is_test': row[2]
+                })
             
             return jsonify({
                 'resource_type': resource_type,
                 'requested': count,
-            'available': available_count,
+                'available': available_resources,
-            'sufficient': available_count >= count,
+                'sufficient': len(available_resources) >= count,
+                'show_test': show_test
+            })
+            
+        except Exception as e:
+            logging.error(f"Fehler beim Prüfen der Verfügbarkeit: {str(e)}")
+            return jsonify({'error': 'Fehler beim Prüfen der Verfügbarkeit'}), 500
+        finally:
+            cur.close()
+            conn.close()
+    
+    # Mehrere Ressourcen gleichzeitig prüfen (für Batch)
+    domain_count = int(request.args.get('domain', 0))
+    ipv4_count = int(request.args.get('ipv4', 0))
+    phone_count = int(request.args.get('phone', 0))
+    is_test = request.args.get('is_test', 'false') == 'true'
+    
+    conn = get_connection()
+    cur = conn.cursor()
+    
+    try:
+        # Zähle verfügbare Ressourcen für jeden Typ
+        result = {}
+        
+        # Domains
+        cur.execute("""
+            SELECT COUNT(*) 
+            FROM resource_pools 
+            WHERE resource_type = 'domain' 
+            AND status = 'available' 
+            AND is_test = %s
+        """, (is_test,))
+        domain_available = cur.fetchone()[0]
+        
+        # IPv4
+        cur.execute("""
+            SELECT COUNT(*) 
+            FROM resource_pools 
+            WHERE resource_type = 'ipv4' 
+            AND status = 'available' 
+            AND is_test = %s
+        """, (is_test,))
+        ipv4_available = cur.fetchone()[0]
+        
+        # Phones
+        cur.execute("""
+            SELECT COUNT(*) 
+            FROM resource_pools 
+            WHERE resource_type = 'phone' 
+            AND status = 'available' 
+            AND is_test = %s
+        """, (is_test,))
+        phone_available = cur.fetchone()[0]
+        
+        return jsonify({
+            'domain_requested': domain_count,
+            'domain_available': domain_available,
+            'domain_sufficient': domain_available >= domain_count,
+            'ipv4_requested': ipv4_count,
+            'ipv4_available': ipv4_available,
+            'ipv4_sufficient': ipv4_available >= ipv4_count,
+            'phone_requested': phone_count,
+            'phone_available': phone_available,
+            'phone_sufficient': phone_available >= phone_count,
+            'all_sufficient': (
+                domain_available >= domain_count and 
+                ipv4_available >= ipv4_count and 
+                phone_available >= phone_count
+            ),
             'is_test': is_test
         })
         

v2_adminpanel/routes/batch_routes.py

@@ -38,7 +38,7 @@ def batch_create():
             # Form data
             customer_id = int(request.form['customer_id'])
             license_type = request.form['license_type']
-            count = int(request.form['count'])
+            count = int(request.form['quantity'])  # Korrigiert von 'count' zu 'quantity'
             valid_from = request.form['valid_from']
             valid_until = request.form['valid_until']
             device_limit = int(request.form['device_limit'])
@@ -72,15 +72,15 @@ def batch_create():
                 # Erstelle Lizenz
                 cur.execute("""
                     INSERT INTO licenses (
-                        license_key, customer_id, customer_name, customer_email,
+                        license_key, customer_id,
                         license_type, valid_from, valid_until, device_limit,
-                        is_test, created_at, created_by
+                        is_test, created_at
-                    ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                    ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                     RETURNING id
                 """, (
-                    license_key, customer_id, customer[0], customer[1],
+                    license_key, customer_id,
                     license_type, valid_from, valid_until, device_limit,
-                    is_test, datetime.now(), session['username']
+                    is_test, datetime.now()
                 ))
                 
                 license_id = cur.fetchone()[0]
@@ -101,6 +101,8 @@ def batch_create():
             
             # Speichere erstellte Lizenzen in Session für Export
             session['batch_created_licenses'] = created_licenses
+            session['batch_customer_name'] = customer[0]
+            session['batch_customer_email'] = customer[1]
             
             flash(f'{count} Lizenzen erfolgreich erstellt!', 'success')
             
@@ -137,10 +139,11 @@ def batch_export():
         
         cur.execute("""
             SELECT 
-                l.license_key, l.customer_name, l.customer_email,
+                l.license_key, c.name, c.email,
                 l.license_type, l.valid_from, l.valid_until,
                 l.device_limit, l.is_test, l.created_at
             FROM licenses l
+            JOIN customers c ON l.customer_id = c.id
             WHERE l.id = ANY(%s)
             ORDER BY l.id
         """, (license_ids,))
@@ -159,20 +162,13 @@ def batch_export():
                 'created_at': row[8]
             })
         
-        # Erstelle Excel-Export
-        excel_file = create_batch_export(licenses)
-        
         # Lösche aus Session
         session.pop('batch_created_licenses', None)
+        session.pop('batch_customer_name', None)
+        session.pop('batch_customer_email', None)
         
-        # Sende Datei
+        # Erstelle und sende Excel-Export
-        filename = f"batch_licenses_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+        return create_batch_export(licenses)
-        return send_file(
-            excel_file,
-            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-            as_attachment=True,
-            download_name=filename
-        )
         
     except Exception as e:
         logging.error(f"Fehler beim Export: {str(e)}")
@@ -336,16 +332,16 @@ def batch_import():
                     # Erstelle Lizenz
                     cur.execute("""
                         INSERT INTO licenses (
-                            license_key, customer_id, customer_name, customer_email,
+                            license_key, customer_id,
                             license_type, valid_from, valid_until, device_limit,
-                            is_test, created_at, created_by
+                            is_test, created_at
-                        ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                        ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                         RETURNING id
                     """, (
-                        license_key, customer_id, customer_name, email,
+                        license_key, customer_id,
                         row['license_type'], row['valid_from'], row['valid_until'],
                         int(row['device_limit']), row.get('is_test', False),
-                        datetime.now(), session['username']
+                        datetime.now()
                     ))
                     
                     license_id = cur.fetchone()[0]

v2_adminpanel/utils/export.py

@@ -135,9 +135,9 @@ def create_batch_export(licenses):
         export_data.append({
             'Lizenzschlüssel': license['license_key'],
             'Kunde': license.get('customer_name', ''),
-            'Email': license.get('email', ''),
+            'Email': license.get('customer_email', ''),
-            'Max. Benutzer': license.get('max_users', 1),
+            'Lizenztyp': license.get('license_type', 'full').upper(),
-            'Geräte-Limit': license.get('device_limit', 1),
+            'Geräte-Limit': license.get('device_limit', 3),
             'Gültig von': format_datetime_for_export(license.get('valid_from')),
             'Gültig bis': format_datetime_for_export(license.get('valid_until')),
             'Status': 'Aktiv' if license.get('is_active', True) else 'Inaktiv',