django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/apps/tasks/templates/tasks/pages/dashboard-improved.html

@@ -0,0 +1,168 @@
+{% extends 'tasks/layout/base.html' %}
+{% load static %}
+
+{% block extra_css %}
+<style>
+    /* Tab styling - важно для работы табов */
+    .tab-button.active {
+        border-color: #3b82f6 !important;
+        color: #3b82f6 !important;
+    }
+
+    .tab-panel {
+        display: none !important;
+    }
+
+    .tab-panel.active {
+        display: block !important;
+    }
+
+    /* Убираем все остальные табы кроме активного */
+    #queues-tab,
+    #workers-tab,
+    #tasks-tab {
+        display: none;
+    }
+
+    #overview-tab {
+        display: block;
+    }
+</style>
+{% endblock %}
+
+{% block content %}
+{% csrf_token %}
+
+<!-- Management Actions -->
+{% include 'tasks/components/management_actions.html' %}
+
+<!-- Tab Navigation -->
+{% include 'tasks/components/tab_navigation.html' %}
+
+<!-- Tab Content -->
+<div class="tab-content mt-6">
+    <!-- Overview Tab -->
+    <div id="overview-tab" class="tab-panel active">
+        {% include 'tasks/components/overview_content.html' %}
+    </div>
+
+    <!-- Queues Tab -->
+    <div id="queues-tab" class="tab-panel">
+        {% include 'tasks/components/queues_content.html' %}
+    </div>
+
+    <!-- Workers Tab -->
+    <div id="workers-tab" class="tab-panel">
+        {% include 'tasks/components/workers_content.html' %}
+    </div>
+
+    <!-- Tasks Tab -->
+    <div id="tasks-tab" class="tab-panel">
+        {% include 'tasks/components/tasks_content.html' %}
+    </div>
+</div>
+
+<!-- Templates for JavaScript -->
+{% include 'tasks/partials/task_row_template.html' %}
+
+{% endblock %}
+
+{% block extra_js %}
+<!-- Improved API Loading with centralized loader -->
+<script type="module">
+    // Import the API loader and task API
+    import { initializeAPIs, showNotification } from '{% static "js/api-loader.mjs" %}';
+    import { tasksAPI } from '{% static "api/tasks/index.mjs" %}';
+
+    // Initialize the API with error handling wrapper
+    async function setupAPIs() {
+        try {
+            // Load task API with automatic error handling
+            const apis = await initializeAPIs(['tasks']);
+
+            // Make available globally for dashboard modules
+            window.tasksAPI = apis.tasks || tasksAPI;
+
+            // Log successful loading
+            console.log('✅ Tasks API loaded with JSDoc types and error handling');
+            console.log('📚 Available methods:', Object.getOwnPropertyNames(Object.getPrototypeOf(window.tasksAPI)));
+
+            // Show IDE hints example
+            console.log(`
+                💡 IDE Tip: Your editor now provides:
+                - Autocomplete for all API methods
+                - Parameter hints with types
+                - Return type information
+                - Inline documentation
+
+                Try typing: tasksAPI. (and see the suggestions!)
+            `);
+
+            // Test the API connection
+            const healthCheck = await window.tasksAPI.cfgTasksApiQueuesStatusRetrieve();
+            if (healthCheck) {
+                showNotification('API connected successfully', 'success');
+            }
+
+        } catch (error) {
+            console.error('❌ Failed to initialize APIs:', error);
+            showNotification('Failed to load API. Some features may not work.', 'error');
+
+            // Fallback to direct import
+            window.tasksAPI = tasksAPI;
+        }
+    }
+
+    // Setup APIs when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', setupAPIs);
+    } else {
+        setupAPIs();
+    }
+</script>
+
+<!-- Dashboard Modules (now with improved API) -->
+<script type="module" src="{% static 'tasks/js/dashboard/overview.mjs' %}"></script>
+<script type="module" src="{% static 'tasks/js/dashboard/queues.mjs' %}"></script>
+<script type="module" src="{% static 'tasks/js/dashboard/workers.mjs' %}"></script>
+<script type="module" src="{% static 'tasks/js/dashboard/tasks.mjs' %}"></script>
+
+<!-- Main Dashboard Controller -->
+<script type="module" src="{% static 'tasks/js/dashboard/main.mjs' %}"></script>
+
+<!-- Debug Helper -->
+<script type="module">
+    // Add debug helper to window for testing
+    window.debugAPI = {
+        // Test various API methods
+        testStats: async () => {
+            const stats = await window.tasksAPI.tasksApiTasksStatsRetrieve();
+            console.log('Task Statistics:', stats);
+            return stats;
+        },
+
+        testQueues: async () => {
+            const queues = await window.tasksAPI.tasksApiQueuesStatusRetrieve();
+            console.log('Queue Status:', queues);
+            return queues;
+        },
+
+        testWorkers: async () => {
+            const workers = await window.tasksAPI.tasksApiWorkersListRetrieve();
+            console.log('Workers List:', workers);
+            return workers;
+        },
+
+        // Show all available methods
+        showMethods: () => {
+            const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(window.tasksAPI))
+                .filter(m => typeof window.tasksAPI[m] === 'function')
+                .filter(m => !m.startsWith('_'));
+            console.log('📋 Available API Methods:', methods);
+            return methods;
+        }
+    };
+
+    console.log('🔧 Debug helpers available: window.debugAPI');
+</script>
+{% endblock %}

django_cfg/apps/tasks/templates/tasks/pages/dashboard.html

@@ -68,8 +68,27 @@
 {% endblock %}
 
 {% block extra_js %}
-<!-- API Client (не модуль) -->
-<script src="{% static 'tasks/js/api.js' %}"></script>
+<!-- Load and initialize Tasks API -->
+<script type="module">
+try {
+    console.log('🔄 Starting TasksAPI module import...');
+    const { loadAPI, showNotification } = await import('/static/js/api-loader.mjs');
+
+    // Load tasks API
+    const tasksAPI = await loadAPI('tasks');
+    console.log('✅ TasksAPI module imported successfully:', tasksAPI);
+
+    // Make it available globally as tasksAPI
+    window.tasksAPI = tasksAPI;
+    window.showNotification = showNotification;
+
+    console.log('✅ TasksAPI loaded from generated MJS client');
+} catch (error) {
+    console.error('❌ Failed to load TasksAPI module:', error);
+    console.error('Error stack:', error.stack);
+    window.tasksAPI = null;
+}
+</script>
 
 <!-- Dashboard Modules -->
 <script type="module" src="{% static 'tasks/js/dashboard/overview.mjs' %}"></script>

django_cfg/apps/tasks/urls.py

@@ -4,8 +4,9 @@ URLs for Django CFG Tasks app.
 Provides RESTful endpoints for task queue management and monitoring using ViewSets and routers.
 """
 
-from django.urls import path, include
+from django.urls import include, path
 from rest_framework.routers import DefaultRouter
+
 from .views import TaskManagementViewSet
 
 app_name = 'tasks'
@@ -17,5 +18,5 @@ router.register(r'', TaskManagementViewSet, basename='task-management')
 urlpatterns = [
     # RESTful API endpoints using ViewSets
     path('api/', include(router.urls)),
-    
+
 ]

django_cfg/apps/tasks/urls_admin.py

@@ -5,6 +5,7 @@ Provides RESTful endpoints for task queue management and monitoring using ViewSe
 """
 
 from django.urls import path
+
 from .views import dashboard_view
 
 urlpatterns = [

django_cfg/apps/tasks/utils/simulator.py

@@ -5,37 +5,34 @@ This module provides real-time access to Dramatiq queue data from Redis,
 with optional test task generation for demonstration purposes.
 """
 
-import json
-import time
+import logging
 import random
-import redis
-from datetime import datetime, timedelta
-from typing import Dict, Any, List, Optional
+from datetime import datetime
+from typing import Any, Dict, Optional
 from urllib.parse import urlparse
+
+import redis
 from django.conf import settings
-from django.core.cache import cache
-import dramatiq
-import logging
 
 logger = logging.getLogger(__name__)
 
 
 class TaskSimulator:
     """Real Dramatiq data provider with test task generation capabilities."""
-    
+
     def __init__(self):
         """Initialize with Redis connection for real Dramatiq data."""
         self.queues = ['critical', 'high', 'default', 'low', 'background', 'payments', 'agents', 'knowbase']
         self._redis_client = None
         self._setup_redis_connection()
-    
+
     def _setup_redis_connection(self):
         """Setup Redis connection for real Dramatiq data."""
         try:
             # Get Redis URL from Django settings (DRAMATIQ_BROKER)
             dramatiq_config = getattr(settings, 'DRAMATIQ_BROKER', {})
             redis_url = dramatiq_config.get('OPTIONS', {}).get('url')
-            
+
             if redis_url:
                 parsed = urlparse(redis_url)
                 self._redis_client = redis.Redis(
@@ -49,11 +46,11 @@ class TaskSimulator:
                 logger.info(f"Connected to Redis: {redis_url}")
             else:
                 logger.warning("No Redis URL found in DRAMATIQ_BROKER settings")
-            
+
         except Exception as e:
             logger.error(f"Failed to connect to Redis: {e}")
             self._redis_client = None
-    
+
     def get_current_queue_status(self) -> Dict[str, Any]:
         """
         Get current queue status from real Dramatiq Redis data.
@@ -63,13 +60,13 @@ class TaskSimulator:
         """
         if not self._redis_client:
             return self._get_no_connection_response()
-        
+
         try:
             queues_data = {}
             total_pending = 0
             total_failed = 0
             active_queues = 0
-            
+
             # Get real queue data from Redis
             for queue_name in self.queues:
                 # Get queue length (pending tasks) - Dramatiq uses dramatiq:{queue_name}.msgs format
@@ -77,13 +74,13 @@ class TaskSimulator:
                     pending = self._redis_client.hlen(f'dramatiq:{queue_name}.msgs')
                 except:
                     pending = 0
-                
-                # Get failed queue length - Dramatiq uses dramatiq:{queue_name}.DQ format  
+
+                # Get failed queue length - Dramatiq uses dramatiq:{queue_name}.DQ format
                 try:
                     failed = self._redis_client.llen(f'dramatiq:{queue_name}.DQ')
                 except:
                     failed = 0
-                
+
                 if pending > 0 or failed > 0:
                     active_queues += 1
                     queues_data[queue_name] = {
@@ -92,16 +89,16 @@ class TaskSimulator:
                         'processed': 0,  # Can't easily get this from Redis
                         'last_activity': datetime.now().isoformat()
                     }
-                    
+
                 total_pending += pending
                 total_failed += failed
-            
+
             # Get worker count from heartbeats - Dramatiq uses dramatiq:__heartbeats__ sorted set
             try:
                 active_workers = self._redis_client.zcard('dramatiq:__heartbeats__')
             except:
                 active_workers = 0
-            
+
             return {
                 'queues': queues_data,
                 'workers': active_workers,
@@ -112,11 +109,11 @@ class TaskSimulator:
                 'total_failed': total_failed,
                 'active_queues': active_queues
             }
-            
+
         except Exception as e:
             logger.error(f"Error getting queue status: {e}")
             return self._get_error_response(str(e))
-    
+
     def get_current_workers_list(self) -> Dict[str, Any]:
         """
         Get current workers list from real Dramatiq Redis data.
@@ -133,7 +130,7 @@ class TaskSimulator:
                 'timestamp': datetime.now().isoformat(),
                 'simulated': False
             }
-        
+
         try:
             workers = []
             # Get worker IDs from heartbeats - Dramatiq uses dramatiq:__heartbeats__ sorted set
@@ -141,7 +138,7 @@ class TaskSimulator:
                 worker_ids = self._redis_client.zrange('dramatiq:__heartbeats__', 0, -1)
             except:
                 worker_ids = []
-            
+
             for worker_id in worker_ids:
                 # Create worker info from heartbeat data
                 workers.append({
@@ -154,7 +151,7 @@ class TaskSimulator:
                     'last_heartbeat': datetime.now().isoformat(),
                     'uptime': 'Active'  # Since it's in heartbeats, it's active
                 })
-            
+
             return {
                 'workers': workers,
                 'active_count': len(workers),
@@ -162,7 +159,7 @@ class TaskSimulator:
                 'timestamp': datetime.now().isoformat(),
                 'simulated': False
             }
-            
+
         except Exception as e:
             logger.error(f"Error getting workers list: {e}")
             return {
@@ -173,7 +170,7 @@ class TaskSimulator:
                 'timestamp': datetime.now().isoformat(),
                 'simulated': False
             }
-    
+
     def get_current_task_statistics(self) -> Dict[str, Any]:
         """
         Get current task statistics from real Dramatiq Redis data.
@@ -189,19 +186,19 @@ class TaskSimulator:
                 'timestamp': datetime.now().isoformat(),
                 'simulated': False
             }
-        
+
         try:
             # Calculate statistics from queue data
             queue_status = self.get_current_queue_status()
-            
+
             total_pending = queue_status.get('total_pending', 0)
             total_failed = queue_status.get('total_failed', 0)
-            
+
             # Estimate completed tasks (this is approximate)
             estimated_completed = random.randint(100, 1000)  # Would need persistent storage for real data
-            
+
             total_tasks = total_pending + total_failed + estimated_completed
-            
+
             statistics = {
                 'total': total_tasks,
                 'completed': estimated_completed,
@@ -211,14 +208,14 @@ class TaskSimulator:
                 'tasks_per_minute': round(random.uniform(5, 50), 1),  # Would need real tracking
                 'success_rate': round((estimated_completed / max(total_tasks, 1)) * 100, 1) if total_tasks > 0 else 100
             }
-            
+
             return {
                 'statistics': statistics,
                 'recent_tasks': [],  # Would need task history storage for real data
                 'timestamp': datetime.now().isoformat(),
                 'simulated': False
             }
-            
+
         except Exception as e:
             logger.error(f"Error getting task statistics: {e}")
             return {
@@ -228,7 +225,7 @@ class TaskSimulator:
                 'timestamp': datetime.now().isoformat(),
                 'simulated': False
             }
-    
+
     def run_simulation(self, workers: int = 3, clear_first: bool = True) -> Dict[str, Any]:
         """
         Generate test tasks for demonstration purposes.
@@ -243,7 +240,7 @@ class TaskSimulator:
         try:
             # Generate realistic test tasks using Dramatiq
             tasks_created = self._generate_test_tasks()
-            
+
             return {
                 'success': True,
                 'message': f'Generated {tasks_created} test tasks for demonstration',
@@ -253,14 +250,14 @@ class TaskSimulator:
                     'timestamp': datetime.now().isoformat()
                 }
             }
-            
+
         except Exception as e:
             logger.error(f"Test task generation failed: {e}")
             return {
                 'success': False,
                 'error': f'Test task generation failed: {str(e)}'
             }
-    
+
     def clear_all_data(self) -> Dict[str, Any]:
         """
         Clear all tasks from Dramatiq queues.
@@ -273,10 +270,10 @@ class TaskSimulator:
                 'success': False,
                 'error': 'Redis connection not available'
             }
-        
+
         try:
             cleared_count = 0
-            
+
             # Clear all queue data
             for queue_name in self.queues:
                 # Clear main queue - Dramatiq uses dramatiq:{queue_name} format
@@ -284,26 +281,26 @@ class TaskSimulator:
                 if main_queue_len > 0:
                     self._redis_client.delete(f'dramatiq:{queue_name}')
                     cleared_count += main_queue_len
-                
+
                 # Clear failed queue - Dramatiq uses dramatiq:{queue_name}.DQ format
                 failed_queue_len = self._redis_client.llen(f'dramatiq:{queue_name}.DQ')
                 if failed_queue_len > 0:
                     self._redis_client.delete(f'dramatiq:{queue_name}.DQ')
                     cleared_count += failed_queue_len
-            
+
             return {
                 'success': True,
                 'message': f'Cleared {cleared_count} tasks from all queues',
                 'cleared_tasks': cleared_count
             }
-            
+
         except Exception as e:
             logger.error(f"Clear operation failed: {e}")
             return {
                 'success': False,
                 'error': f'Clear operation failed: {str(e)}'
             }
-    
+
     def _generate_test_tasks(self) -> int:
         """Generate realistic test tasks for demonstration."""
         try:
@@ -313,26 +310,26 @@ class TaskSimulator:
         except ImportError as e:
             logger.error(f"Failed to import demo tasks: {e}")
             return 0
-    
+
     def _calculate_uptime(self, started_at: Optional[str]) -> str:
         """Calculate uptime from start time."""
         if not started_at:
             return 'Unknown'
-        
+
         try:
             start_time = datetime.fromisoformat(started_at.replace('Z', '+00:00'))
             uptime = datetime.now() - start_time.replace(tzinfo=None)
-            
+
             hours = int(uptime.total_seconds() // 3600)
             minutes = int((uptime.total_seconds() % 3600) // 60)
-            
+
             if hours > 0:
                 return f'{hours}h {minutes}m'
             else:
                 return f'{minutes}m'
         except:
             return 'Unknown'
-    
+
     def _get_no_connection_response(self) -> Dict[str, Any]:
         """Return response when Redis connection is not available."""
         return {
@@ -343,7 +340,7 @@ class TaskSimulator:
             'timestamp': datetime.now().isoformat(),
             'simulated': False
         }
-    
+
     def _get_error_response(self, error_message: str) -> Dict[str, Any]:
         """Return error response."""
         return {
@@ -353,4 +350,4 @@ class TaskSimulator:
             'redis_connected': False,
             'timestamp': datetime.now().isoformat(),
             'simulated': False
-        }
+        }