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

django_cfg/apps/tasks/static/tasks/js/dashboard/main.mjs

@@ -118,17 +118,19 @@ class TasksDashboard {
 
     /**
      * Management actions
+     * Using new MJS API with correct method names
      */
     async simulateData() {
         try {
             this.showManagementActionStatus('Simulating test data...', 'info');
-            const response = await this.api.simulateData();
-            
-            if (response.success) {
+            // Using the new API method name from MJS client
+            const response = await this.api.tasksApiSimulateCreate({});
+
+            if (response && response.success) {
                 this.showManagementActionStatus('Test data simulation completed successfully', 'success');
                 await this.loadTabData(this.currentTab);
             } else {
-                this.showManagementActionStatus(`Simulation failed: ${response.error}`, 'error');
+                this.showManagementActionStatus(`Simulation failed: ${response?.error || 'Unknown error'}`, 'error');
             }
         } catch (error) {
             this.showManagementActionStatus(`Simulation error: ${error.message}`, 'error');
@@ -138,13 +140,14 @@ class TasksDashboard {
     async clearData() {
         try {
             this.showManagementActionStatus('Clearing test data...', 'info');
-            const response = await this.api.clearData();
-            
-            if (response.success) {
+            // Using the new API method name from MJS client
+            const response = await this.api.tasksApiClearCreate({});
+
+            if (response && response.success) {
                 this.showManagementActionStatus('Test data cleared successfully', 'success');
                 await this.loadTabData(this.currentTab);
             } else {
-                this.showManagementActionStatus(`Clear failed: ${response.error}`, 'error');
+                this.showManagementActionStatus(`Clear failed: ${response?.error || 'Unknown error'}`, 'error');
             }
         } catch (error) {
             this.showManagementActionStatus(`Clear error: ${error.message}`, 'error');
@@ -155,12 +158,13 @@ class TasksDashboard {
         console.log('Clearing queues...');
         this.showManagementActionStatus('Clearing all queues...', 'info');
         try {
-            const response = await this.api.clearQueues();
-            if (response.success) {
-                this.showManagementActionStatus(response.message, 'success');
+            // Using the new API method name from MJS client
+            const response = await this.api.tasksApiClearQueuesCreate({});
+            if (response && response.success) {
+                this.showManagementActionStatus(response.message || 'Queues cleared successfully', 'success');
                 this.loadTabData(this.currentTab);
             } else {
-                this.showManagementActionStatus(`Failed to clear queues: ${response.error}`, 'error');
+                this.showManagementActionStatus(`Failed to clear queues: ${response?.error || 'Unknown error'}`, 'error');
             }
         } catch (error) {
             this.showManagementActionStatus(`Failed to clear queues: ${error.message}`, 'error');
@@ -171,12 +175,13 @@ class TasksDashboard {
         console.log('Purging failed tasks...');
         this.showManagementActionStatus('Purging failed tasks...', 'info');
         try {
-            const response = await this.api.purgeFailed();
-            if (response.success) {
-                this.showManagementActionStatus(response.message, 'success');
+            // Using the new API method name from MJS client
+            const response = await this.api.tasksApiPurgeFailedCreate({});
+            if (response && response.success) {
+                this.showManagementActionStatus(response.message || 'Failed tasks purged successfully', 'success');
                 this.loadTabData(this.currentTab);
             } else {
-                this.showManagementActionStatus(`Failed to purge failed tasks: ${response.error}`, 'error');
+                this.showManagementActionStatus(`Failed to purge failed tasks: ${response?.error || 'Unknown error'}`, 'error');
             }
         } catch (error) {
             this.showManagementActionStatus(`Failed to purge failed tasks: ${error.message}`, 'error');
@@ -237,9 +242,28 @@ class TasksDashboard {
     }
 }
 
-// Initialize dashboard when DOM is ready
-document.addEventListener('DOMContentLoaded', () => {
-    console.log('DOM loaded, initializing dashboard...');
+// Wait for both DOM and API to be ready
+async function initializeDashboard() {
+    console.log('DOM loaded, waiting for TasksAPI...');
+
+    // Wait for API to be available (max 5 seconds)
+    let attempts = 0;
+    const maxAttempts = 100; // 100 * 50ms = 5 seconds
+
+    while (!window.tasksAPI && attempts < maxAttempts) {
+        await new Promise(resolve => setTimeout(resolve, 50));
+        attempts++;
+    }
+
+    if (!window.tasksAPI) {
+        console.error('❌ TasksAPI failed to load after 5 seconds');
+        return;
+    }
+
+    console.log('✅ TasksAPI ready, initializing dashboard...');
     window.dashboard = new TasksDashboard();
     window.dashboard.init();
-});
+}
+
+// Initialize dashboard when DOM is ready
+document.addEventListener('DOMContentLoaded', initializeDashboard);

django_cfg/apps/tasks/static/tasks/js/dashboard/overview.mjs

@@ -10,18 +10,20 @@ export class OverviewModule {
 
     /**
      * Load overview data
+     * Using new MJS API methods with JSDoc types
      */
     async loadData() {
         try {
             console.log('Loading overview data...');
-            
+
+            // Using the new API method names from MJS client
             const [queueData, taskStats] = await Promise.all([
-                this.api.getQueueStatus(),
-                this.api.getTaskStatistics()
+                this.api.tasksApiQueuesStatusRetrieve(),
+                this.api.tasksApiTasksStatsRetrieve()
             ]);
 
-            const queueInfo = queueData.data || queueData;
-            const taskInfo = taskStats.data || taskStats;
+            const queueInfo = queueData?.data || queueData;
+            const taskInfo = taskStats?.data || taskStats;
 
             this.updateStatusCards(queueInfo, taskInfo);
             this.updateSystemStatus(queueInfo);

django_cfg/apps/tasks/static/tasks/js/dashboard/queues.mjs

@@ -10,13 +10,15 @@ export class QueuesModule {
 
     /**
      * Load queues data
+     * Using new MJS API method with JSDoc types
      */
     async loadData() {
         try {
             console.log('Loading queues data...');
-            
-            const response = await this.api.getQueueStatus();
-            const data = response.data || response;
+
+            // Using the new API method name from MJS client
+            const response = await this.api.tasksApiQueuesStatusRetrieve();
+            const data = response?.data || response;
             
             this.renderQueuesData(data);
             

django_cfg/apps/tasks/static/tasks/js/dashboard/tasks.mjs

@@ -47,13 +47,15 @@ export class TasksModule {
 
     /**
      * Load tasks data
+     * Using new MJS API method with JSDoc types
      */
     async loadData() {
         try {
             console.log('Loading tasks data...');
-            
-            const response = await this.api.getTaskList();
-            const data = response.data || response;
+
+            // Using the new API method name from MJS client
+            const response = await this.api.tasksApiTasksListRetrieve();
+            const data = response?.data || response;
             
             if (data.tasks && data.tasks.length > 0) {
                 this.allTasks = data.tasks;

django_cfg/apps/tasks/static/tasks/js/dashboard/workers.mjs

@@ -10,13 +10,15 @@ export class WorkersModule {
 
     /**
      * Load workers data
+     * Using new MJS API method with JSDoc types
      */
     async loadData() {
         try {
             console.log('Loading workers data...');
-            
-            const response = await this.api.getWorkersList();
-            const data = response.data || response;
+
+            // Using the new API method name from MJS client
+            const response = await this.api.tasksApiWorkersListRetrieve();
+            const data = response?.data || response;
             
             this.renderWorkersData(data);
             

django_cfg/apps/tasks/tasks/demo_tasks.py

@@ -5,12 +5,13 @@ These tasks are used to generate test data for the dashboard
 and demonstrate different queue behaviors and execution times.
 """
 
-import dramatiq
-import time
-import random
 import logging
+import random
+import time
 from datetime import datetime
 
+import dramatiq
+
 logger = logging.getLogger(__name__)
 
 
@@ -88,46 +89,46 @@ def generate_demo_tasks() -> int:
         Number of tasks created
     """
     tasks_count = 0
-    
+
     # Quick tasks (3-5 tasks)
     for i in range(random.randint(3, 5)):
         quick_task.send(f'quick_{i+1}', random.randint(2, 3))
         tasks_count += 1
-    
+
     # Medium tasks (2-4 tasks)
     for i in range(random.randint(2, 4)):
         medium_task.send(f'medium_{i+1}', random.randint(5, 8))
         tasks_count += 1
-    
+
     # Slow tasks (1-2 tasks)
     for i in range(random.randint(1, 2)):
         slow_task.send(f'slow_{i+1}', random.randint(10, 15))
         tasks_count += 1
-    
+
     # Critical tasks (2-3 tasks)
     for i in range(random.randint(2, 3)):
         critical_task.send(f'critical_{i+1}', random.randint(2, 4))
         tasks_count += 1
-    
+
     # Payment tasks (1-3 tasks)
     for i in range(random.randint(1, 3)):
         amount = round(random.uniform(10.0, 500.0), 2)
         payment_task.send(f'payment_{i+1}', amount)
         tasks_count += 1
-    
+
     # Agent tasks (1-2 tasks)
     for i in range(random.randint(1, 2)):
         queries = ['analyze data', 'generate report', 'process document', 'classify content']
         query = random.choice(queries)
         agent_task.send(f'agent_{i+1}', query)
         tasks_count += 1
-    
+
     # Priority tasks (1-2 tasks)
     for i in range(random.randint(1, 2)):
         priority_levels = ['urgent', 'high', 'critical']
         priority = random.choice(priority_levels)
         priority_task.send(f'priority_{i+1}', priority)
         tasks_count += 1
-    
+
     logger.info(f"Generated {tasks_count} demo tasks across all queues")
     return tasks_count

django_cfg/apps/tasks/templates/tasks/components/tasks_mjs_integration.html

@@ -0,0 +1,269 @@
+<!-- Example of MJS API client integration in Django template -->
+{% load static %}
+
+<div id="tasks-dashboard" class="bg-white dark:bg-gray-800 rounded-xl shadow-sm border border-gray-200 dark:border-gray-700">
+    <!-- Header -->
+    <div class="px-6 py-4 border-b border-gray-200 dark:border-gray-700">
+        <div class="flex items-center justify-between">
+            <h2 class="text-lg font-semibold text-gray-900 dark:text-white">Tasks Dashboard (MJS)</h2>
+            <button id="refresh-btn" class="px-3 py-1 text-sm bg-purple-600 text-white rounded hover:bg-purple-700">
+                Refresh
+            </button>
+        </div>
+    </div>
+
+    <!-- Stats -->
+    <div id="task-stats" class="p-6">
+        <div class="grid grid-cols-4 gap-4">
+            <div class="bg-gray-50 dark:bg-gray-700 p-4 rounded-lg">
+                <div class="text-sm text-gray-600 dark:text-gray-400">Total Tasks</div>
+                <div id="total-tasks" class="text-2xl font-bold text-gray-900 dark:text-white">-</div>
+            </div>
+            <div class="bg-green-50 dark:bg-green-900 p-4 rounded-lg">
+                <div class="text-sm text-green-600 dark:text-green-400">Completed</div>
+                <div id="completed-tasks" class="text-2xl font-bold text-green-900 dark:text-green-100">-</div>
+            </div>
+            <div class="bg-yellow-50 dark:bg-yellow-900 p-4 rounded-lg">
+                <div class="text-sm text-yellow-600 dark:text-yellow-400">Running</div>
+                <div id="running-tasks" class="text-2xl font-bold text-yellow-900 dark:text-yellow-100">-</div>
+            </div>
+            <div class="bg-red-50 dark:bg-red-900 p-4 rounded-lg">
+                <div class="text-sm text-red-600 dark:text-red-400">Failed</div>
+                <div id="failed-tasks" class="text-2xl font-bold text-red-900 dark:text-red-100">-</div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Task List -->
+    <div class="p-6 border-t border-gray-200 dark:border-gray-700">
+        <h3 class="text-md font-semibold text-gray-900 dark:text-white mb-4">Recent Tasks</h3>
+        <div id="task-list" class="space-y-2">
+            <!-- Tasks will be inserted here -->
+        </div>
+    </div>
+
+    <!-- Loading State -->
+    <div id="loading" class="hidden p-6 text-center">
+        <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-purple-600 mx-auto"></div>
+        <p class="mt-2 text-gray-600 dark:text-gray-400">Loading tasks...</p>
+    </div>
+
+    <!-- Error State -->
+    <div id="error" class="hidden p-6 text-center">
+        <div class="text-red-600 dark:text-red-400">
+            <span class="material-icons text-5xl">error</span>
+            <p class="mt-2">Failed to load tasks</p>
+            <p id="error-message" class="text-sm mt-1"></p>
+        </div>
+    </div>
+</div>
+
+<script type="module">
+// Import the MJS API client
+import { tasksAPI } from '{% static "api/tasks.mjs" %}';
+
+// State management
+let currentTasks = [];
+let autoRefreshInterval = null;
+
+// DOM elements
+const elements = {
+    totalTasks: document.getElementById('total-tasks'),
+    completedTasks: document.getElementById('completed-tasks'),
+    runningTasks: document.getElementById('running-tasks'),
+    failedTasks: document.getElementById('failed-tasks'),
+    taskList: document.getElementById('task-list'),
+    loading: document.getElementById('loading'),
+    error: document.getElementById('error'),
+    errorMessage: document.getElementById('error-message'),
+    refreshBtn: document.getElementById('refresh-btn')
+};
+
+// Show loading state
+function showLoading() {
+    elements.loading.classList.remove('hidden');
+    elements.error.classList.add('hidden');
+}
+
+// Hide loading state
+function hideLoading() {
+    elements.loading.classList.add('hidden');
+}
+
+// Show error
+function showError(message) {
+    elements.error.classList.remove('hidden');
+    elements.errorMessage.textContent = message;
+    hideLoading();
+}
+
+// Update statistics
+async function updateStats() {
+    try {
+        const stats = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
+
+        elements.totalTasks.textContent = stats.total || 0;
+        elements.completedTasks.textContent = stats.completed || 0;
+        elements.runningTasks.textContent = stats.running || 0;
+        elements.failedTasks.textContent = stats.failed || 0;
+    } catch (error) {
+        console.error('Failed to fetch stats:', error);
+    }
+}
+
+// Render task item
+function renderTaskItem(task) {
+    const statusColors = {
+        'completed': 'text-green-600 bg-green-100',
+        'running': 'text-yellow-600 bg-yellow-100',
+        'failed': 'text-red-600 bg-red-100',
+        'pending': 'text-gray-600 bg-gray-100'
+    };
+
+    const statusColor = statusColors[task.status] || 'text-gray-600 bg-gray-100';
+
+    return `
+        <div class="flex items-center justify-between p-3 bg-gray-50 dark:bg-gray-700 rounded-lg">
+            <div class="flex items-center space-x-3">
+                <span class="px-2 py-1 text-xs font-medium rounded ${statusColor}">
+                    ${task.status}
+                </span>
+                <div>
+                    <div class="font-medium text-gray-900 dark:text-white">${task.name}</div>
+                    <div class="text-sm text-gray-500 dark:text-gray-400">
+                        ${task.queue || 'default'} • ${new Date(task.created_at).toLocaleString()}
+                    </div>
+                </div>
+            </div>
+            <div class="text-sm text-gray-500 dark:text-gray-400">
+                ${task.duration || '-'} ms
+            </div>
+        </div>
+    `;
+}
+
+// Load tasks
+async function loadTasks() {
+    showLoading();
+
+    try {
+        // Fetch tasks list
+        const response = await tasksAPI.cfgTasksApiTasksListRetrieve();
+        currentTasks = response.tasks || [];
+
+        // Update stats
+        await updateStats();
+
+        // Render task list
+        if (currentTasks.length > 0) {
+            elements.taskList.innerHTML = currentTasks
+                .slice(0, 10)  // Show only first 10 tasks
+                .map(task => renderTaskItem(task))
+                .join('');
+        } else {
+            elements.taskList.innerHTML = `
+                <div class="text-center py-8 text-gray-500 dark:text-gray-400">
+                    No tasks found
+                </div>
+            `;
+        }
+
+        hideLoading();
+    } catch (error) {
+        console.error('Failed to load tasks:', error);
+        showError(error.message || 'Failed to load tasks');
+    }
+}
+
+// Clear all tasks
+async function clearAllTasks() {
+    if (!confirm('Are you sure you want to clear all tasks?')) {
+        return;
+    }
+
+    try {
+        await tasksAPI.cfgTasksApiClearCreate({});
+        await loadTasks();
+        alert('All tasks cleared successfully');
+    } catch (error) {
+        console.error('Failed to clear tasks:', error);
+        alert('Failed to clear tasks: ' + error.message);
+    }
+}
+
+// Simulate tasks
+async function simulateTasks(count = 5) {
+    try {
+        await tasksAPI.cfgTasksApiSimulateCreate({
+            count: count,
+            queue: 'default',
+            task_type: 'test'
+        });
+        await loadTasks();
+    } catch (error) {
+        console.error('Failed to simulate tasks:', error);
+        alert('Failed to simulate tasks: ' + error.message);
+    }
+}
+
+// Setup auto-refresh
+function startAutoRefresh(interval = 5000) {
+    stopAutoRefresh();
+    autoRefreshInterval = setInterval(() => {
+        loadTasks();
+    }, interval);
+}
+
+function stopAutoRefresh() {
+    if (autoRefreshInterval) {
+        clearInterval(autoRefreshInterval);
+        autoRefreshInterval = null;
+    }
+}
+
+// Event listeners
+elements.refreshBtn.addEventListener('click', () => {
+    loadTasks();
+});
+
+// Keyboard shortcuts
+document.addEventListener('keydown', (e) => {
+    // Ctrl+R or Cmd+R to refresh
+    if ((e.ctrlKey || e.metaKey) && e.key === 'r') {
+        e.preventDefault();
+        loadTasks();
+    }
+
+    // Ctrl+Shift+C to clear tasks
+    if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === 'C') {
+        e.preventDefault();
+        clearAllTasks();
+    }
+
+    // Ctrl+Shift+S to simulate tasks
+    if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === 'S') {
+        e.preventDefault();
+        simulateTasks();
+    }
+});
+
+// Initialize on page load
+loadTasks();
+
+// Start auto-refresh (update every 5 seconds)
+startAutoRefresh(5000);
+
+// Cleanup on page unload
+window.addEventListener('beforeunload', () => {
+    stopAutoRefresh();
+});
+
+// Export functions for external use
+window.tasksDashboard = {
+    loadTasks,
+    clearAllTasks,
+    simulateTasks,
+    startAutoRefresh,
+    stopAutoRefresh
+};
+</script>