django-cfg 1.4.10__py3-none-any.whl → 1.4.13__py3-none-any.whl

django_cfg/modules/django_tasks/management/commands/task_status.py

@@ -0,0 +1,257 @@
+"""
+Django management command for checking task system status.
+
+This command provides comprehensive status information about the
+Dramatiq task system, including queue statistics, worker status,
+and configuration details.
+"""
+
+from django.core.management.base import BaseCommand, CommandError
+from django.conf import settings
+from typing import Any, Dict, List
+import json
+import logging
+from django_cfg.modules.django_logging import get_logger
+
+logger = get_logger('task_status')
+
+
+class Command(BaseCommand):
+    """
+    Display comprehensive task system status.
+
+    Shows information about:
+    - Task system configuration
+    - Redis connection status
+    - Queue statistics
+    - Worker status
+    - Discovered task modules
+    """
+
+    # Web execution metadata
+    web_executable = True
+    requires_input = False
+    is_destructive = False
+
+    help = "Display task system status and statistics"
+    
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            "--format",
+            choices=["text", "json"],
+            default="text",
+            help="Output format (default: text)",
+        )
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Show detailed information",
+        )
+    
+    def handle(self, *args, **options):
+        """Handle the command execution."""
+        logger.info("Starting task_status command")
+        try:
+            # Import here to avoid issues if dramatiq is not installed
+            from django_cfg.modules.django_tasks import get_task_service
+            
+            # Get task service
+            task_service = get_task_service()
+            
+            # Get comprehensive health status
+            status = task_service.get_health_status()
+            
+            # Format and display output
+            if options["format"] == "json":
+                self._output_json(status)
+            else:
+                self._output_text(status, options["verbose"])
+                
+        except ImportError:
+            raise CommandError(
+                "Dramatiq dependencies not installed. "
+                "Install with: pip install django-cfg[tasks]"
+            )
+        except Exception as e:
+            logger.exception("Failed to get task status")
+            raise CommandError(f"Failed to get status: {e}")
+    
+    def _output_json(self, status: Dict[str, Any]):
+        """Output status in JSON format."""
+        self.stdout.write(json.dumps(status, indent=2, default=str))
+    
+    def _output_text(self, status: Dict[str, Any], verbose: bool):
+        """Output status in human-readable text format."""
+        # Header
+        self.stdout.write(
+            self.style.SUCCESS("=== Django-CFG Task System Status ===")
+        )
+        self.stdout.write()
+        
+        # Basic status
+        enabled = status.get("enabled", False)
+        if enabled:
+            self.stdout.write(
+                self.style.SUCCESS("✓ Task system is ENABLED")
+            )
+        else:
+            self.stdout.write(
+                self.style.ERROR("✗ Task system is DISABLED")
+            )
+            return
+        
+        # Redis connection
+        redis_ok = status.get("redis_connection", False)
+        if redis_ok:
+            self.stdout.write(
+                self.style.SUCCESS("✓ Redis connection is OK")
+            )
+        else:
+            self.stdout.write(
+                self.style.ERROR("✗ Redis connection FAILED")
+            )
+        
+        # Configuration validation
+        config_valid = status.get("configuration_valid", False)
+        if config_valid:
+            self.stdout.write(
+                self.style.SUCCESS("✓ Configuration is VALID")
+            )
+        else:
+            self.stdout.write(
+                self.style.ERROR("✗ Configuration is INVALID")
+            )
+        
+        self.stdout.write()
+        
+        # Configuration details (if verbose)
+        if verbose:
+            self._show_configuration_details()
+        
+        # Queue statistics
+        queues = status.get("queues", [])
+        if queues:
+            self.stdout.write(
+                self.style.SUCCESS("=== Queue Statistics ===")
+            )
+            for queue in queues:
+                name = queue.get("name", "unknown")
+                pending = queue.get("pending", 0)
+                running = queue.get("running", 0)
+                completed = queue.get("completed", 0)
+                failed = queue.get("failed", 0)
+                
+                self.stdout.write(f"Queue: {name}")
+                self.stdout.write(f"  Pending: {pending}")
+                self.stdout.write(f"  Running: {running}")
+                self.stdout.write(f"  Completed: {completed}")
+                self.stdout.write(f"  Failed: {failed}")
+                self.stdout.write()
+        
+        # Worker status
+        workers = status.get("workers", [])
+        if workers:
+            self.stdout.write(
+                self.style.SUCCESS("=== Worker Status ===")
+            )
+            for worker in workers:
+                worker_id = worker.get("id", "unknown")
+                worker_status = worker.get("status", "unknown")
+                current_task = worker.get("current_task")
+                processed = worker.get("processed_tasks", 0)
+                
+                status_style = (
+                    self.style.SUCCESS if worker_status == "active" 
+                    else self.style.WARNING if worker_status == "idle"
+                    else self.style.ERROR
+                )
+                
+                self.stdout.write(f"Worker: {worker_id}")
+                self.stdout.write(f"  Status: {status_style(worker_status)}")
+                if current_task:
+                    self.stdout.write(f"  Current Task: {current_task}")
+                self.stdout.write(f"  Processed: {processed}")
+                self.stdout.write()
+        else:
+            self.stdout.write(
+                self.style.WARNING("No active workers found")
+            )
+        
+        # Discovered modules
+        modules = status.get("discovered_modules", [])
+        if modules:
+            self.stdout.write(
+                self.style.SUCCESS("=== Discovered Task Modules ===")
+            )
+            for module in modules:
+                self.stdout.write(f"  - {module}")
+            self.stdout.write()
+        else:
+            self.stdout.write(
+                self.style.WARNING("No task modules discovered")
+            )
+        
+        # Error information
+        if "error" in status:
+            self.stdout.write(
+                self.style.ERROR(f"Error: {status['error']}")
+            )
+    
+    def _show_configuration_details(self):
+        """Show detailed configuration information."""
+        try:
+            from django_cfg.modules.django_tasks import get_task_service
+            
+            task_service = get_task_service()
+            config = task_service.config
+            
+            if not config:
+                self.stdout.write(
+                    self.style.WARNING("Configuration not available")
+                )
+                return
+            
+            self.stdout.write(
+                self.style.SUCCESS("=== Configuration Details ===")
+            )
+            
+            # Basic settings
+            self.stdout.write(f"Backend: {config.backend}")
+            self.stdout.write(f"Enabled: {config.enabled}")
+            self.stdout.write(f"Auto-discover: {config.auto_discover_tasks}")
+            self.stdout.write()
+            
+            # Dramatiq settings
+            dramatiq = config.dramatiq
+            self.stdout.write("Dramatiq Configuration:")
+            self.stdout.write(f"  Redis DB: {dramatiq.redis_db}")
+            self.stdout.write(f"  Max Retries: {dramatiq.max_retries}")
+            self.stdout.write(f"  Processes: {dramatiq.processes}")
+            self.stdout.write(f"  Threads: {dramatiq.threads}")
+            self.stdout.write(f"  Queues: {', '.join(dramatiq.queues)}")
+            self.stdout.write(f"  Time Limit: {dramatiq.time_limit_seconds}s")
+            self.stdout.write(f"  Max Age: {dramatiq.max_age_seconds}s")
+            self.stdout.write()
+            
+            # Worker settings
+            worker = config.worker
+            self.stdout.write("Worker Configuration:")
+            self.stdout.write(f"  Log Level: {worker.log_level}")
+            self.stdout.write(f"  Shutdown Timeout: {worker.shutdown_timeout}s")
+            self.stdout.write(f"  Health Check: {worker.health_check_enabled}")
+            if worker.max_memory_mb:
+                self.stdout.write(f"  Memory Limit: {worker.max_memory_mb}MB")
+            self.stdout.write()
+            
+            # Middleware
+            if dramatiq.middleware:
+                self.stdout.write("Middleware Stack:")
+                for middleware in dramatiq.middleware:
+                    self.stdout.write(f"  - {middleware}")
+                self.stdout.write()
+            
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(f"Failed to show configuration: {e}")
+            )

django_cfg/modules/django_telegram/management/commands/test_telegram.py

@@ -0,0 +1,68 @@
+"""
+Test Telegram Command
+
+Tests Telegram notification functionality using django_cfg configuration.
+"""
+
+from django.core.management.base import BaseCommand
+from django_cfg.modules.django_logging import get_logger
+
+
+
+logger = get_logger('test_telegram')
+
+class Command(BaseCommand):
+    """Command to test Telegram functionality."""
+
+    # Web execution metadata
+    web_executable = True
+    requires_input = False
+    is_destructive = False
+
+    help = "Test Telegram notification functionality"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--message",
+            type=str,
+            help="Message to send",
+            default="Test message from UnrealON"
+        )
+
+    def handle(self, *args, **options):
+        logger.info("Starting test_telegram command")
+        message = options["message"]
+
+        self.stdout.write("🚀 Testing Telegram notification service")
+
+        # Get telegram service from django-cfg (автоматически настроен!)
+        try:
+            from django_cfg.modules.django_telegram import DjangoTelegram
+            telegram_service = DjangoTelegram()
+            
+            self.stdout.write("\n📱 Sending test messages...")
+
+            # Send info message (модуль сам знает настройки!)
+            self.stdout.write("\n1️⃣ Sending info message...")
+            telegram_service.send_info(
+                message,
+                {
+                    "Type": "System Test",
+                    "Status": "Running", 
+                    "Environment": "Development"
+                }
+            )
+            self.stdout.write(self.style.SUCCESS("✅ Info message sent!"))
+
+            # Send success message
+            self.stdout.write("\n2️⃣ Sending success message...")
+            telegram_service.send_success(
+                "Test completed successfully!",
+                {"Message": message}
+            )
+            self.stdout.write(self.style.SUCCESS("✅ Success message sent!"))
+
+            self.stdout.write(self.style.SUCCESS("\n✅ All test messages sent successfully!"))
+
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"\n❌ Failed to send Telegram messages: {e}"))

django_cfg/modules/django_twilio/management/commands/test_twilio.py

@@ -0,0 +1,112 @@
+"""
+Test Twilio Command
+
+Tests Twilio messaging functionality using django_cfg configuration.
+"""
+
+from django.core.management.base import BaseCommand
+from django_cfg.modules.django_logging import get_logger
+
+
+
+logger = get_logger('test_twilio')
+
+class Command(BaseCommand):
+    """Command to test Twilio functionality."""
+
+    # Web execution metadata
+    web_executable = True
+    requires_input = False
+    is_destructive = False
+
+    help = "Test Twilio messaging functionality"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--to",
+            type=str,
+            help="Phone number to send test message to",
+            default="+6281339646301"
+        )
+        parser.add_argument(
+            "--message",
+            type=str,
+            help="Message to send",
+            default="Test message from Django CFG Twilio"
+        )
+        parser.add_argument(
+            "--whatsapp",
+            action="store_true",
+            help="Send WhatsApp message (default: SMS)"
+        )
+        parser.add_argument(
+            "--content-sid",
+            type=str,
+            help="Content template SID for WhatsApp (optional)"
+        )
+
+    def handle(self, *args, **options):
+        logger.info("Starting test_twilio command")
+        to_number = options["to"]
+        message = options["message"]
+        is_whatsapp = options["whatsapp"]
+        content_sid = options.get("content_sid")
+
+        self.stdout.write("🚀 Testing Twilio messaging service")
+
+        try:
+            from django_cfg.modules.django_twilio import SimpleTwilioService
+            twilio_service = SimpleTwilioService()
+            
+            if is_whatsapp:
+                self.stdout.write(f"\n📱 Sending WhatsApp message to {to_number}...")
+                
+                if content_sid:
+                    # Send with template
+                    result = twilio_service.send_whatsapp_message(
+                        to=to_number,
+                        body="",  # Not used with templates
+                        content_sid=content_sid,
+                        content_variables={"1": "12/1", "2": "3pm"}
+                    )
+                    self.stdout.write(self.style.SUCCESS("✅ WhatsApp template message sent!"))
+                else:
+                    # Send regular message
+                    result = twilio_service.send_whatsapp_message(
+                        to=to_number,
+                        body=message
+                    )
+                    self.stdout.write(self.style.SUCCESS("✅ WhatsApp message sent!"))
+            else:
+                self.stdout.write(f"\n📱 Sending SMS to {to_number}...")
+                result = twilio_service.send_sms_message(
+                    to=to_number,
+                    body=message
+                )
+                self.stdout.write(self.style.SUCCESS("✅ SMS message sent!"))
+
+            # Show result details
+            self.stdout.write(f"\n📊 Message Details:")
+            self.stdout.write(f"  SID: {result['sid']}")
+            self.stdout.write(f"  Status: {result['status']}")
+            self.stdout.write(f"  To: {result['to']}")
+            self.stdout.write(f"  From: {result['from']}")
+            self.stdout.write(f"  Created: {result['date_created']}")
+            
+            if result.get('price'):
+                self.stdout.write(f"  Price: {result['price']} {result['price_unit']}")
+
+            self.stdout.write(self.style.SUCCESS("\n✅ Twilio test completed successfully!"))
+
+        except ImportError as e:
+            self.stdout.write(self.style.ERROR(f"\n❌ Twilio dependencies not installed: {e}"))
+            self.stdout.write("💡 Install with: pip install twilio")
+            
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"\n❌ Failed to send message: {e}"))
+            self.stdout.write("\n💡 Troubleshooting:")
+            self.stdout.write("  1. Check your Twilio credentials in config.dev.yaml")
+            self.stdout.write("  2. Ensure account_sid starts with 'AC' and is 34 characters")
+            self.stdout.write("  3. Verify auth_token is 32 characters")
+            self.stdout.write("  4. For WhatsApp: use sandbox number +14155238886")
+            self.stdout.write("  5. For SMS: ensure your number is verified")

django_cfg/modules/django_unfold/callbacks/main.py

@@ -19,16 +19,17 @@ from .system import SystemCallbacks
 from .actions import ActionsCallbacks
 from .charts import ChartsCallbacks
 from .commands import CommandsCallbacks
-from .revolution import RevolutionCallbacks
+from .revolution import OpenAPIClientCallbacks
 from .users import UsersCallbacks
 from .base import get_user_admin_urls
 
 # Import new dashboard sections
-from django_cfg.dashboard.sections.overview import OverviewSection
-from django_cfg.dashboard.sections.stats import StatsSection
-from django_cfg.dashboard.sections.system import SystemSection
-from django_cfg.dashboard.sections.commands import CommandsSection
-from django_cfg.dashboard.debug import save_section_render
+from django_cfg.modules.django_dashboard.sections.overview import OverviewSection
+from django_cfg.modules.django_dashboard.sections.stats import StatsSection
+from django_cfg.modules.django_dashboard.sections.system import SystemSection
+from django_cfg.modules.django_dashboard.sections.commands import CommandsSection
+from django_cfg.modules.django_dashboard.sections.documentation import DocumentationSection
+from django_cfg.modules.django_dashboard.debug import save_section_render
 
 logger = logging.getLogger(__name__)
 
@@ -40,7 +41,7 @@ class UnfoldCallbacks(
     ActionsCallbacks,
     ChartsCallbacks,
     CommandsCallbacks,
-    RevolutionCallbacks,
+    OpenAPIClientCallbacks,
     UsersCallbacks
 ):
     """
@@ -145,6 +146,15 @@ class UnfoldCallbacks(
                 logger.error(f"Failed to render commands section: {e}", exc_info=True)
                 commands_section = None
 
+            try:
+                documentation_section = DocumentationSection(request).render()
+                # Debug: save render (only in debug mode)
+                if config and config.debug:
+                    save_section_render('documentation', documentation_section)
+            except Exception as e:
+                logger.error(f"Failed to render documentation section: {e}", exc_info=True)
+                documentation_section = None
+
             # Combine all stat cards (data already loaded above)
             all_stats = user_stats + support_stats
 
@@ -165,6 +175,7 @@ class UnfoldCallbacks(
                 "stats_section": stats_section,
                 "system_section": system_section,
                 "commands_section": commands_section,
+                "documentation_section": documentation_section,
 
                 # Statistics cards
                 "cards": cards_data,
@@ -198,8 +209,8 @@ class UnfoldCallbacks(
                     for action in dashboard_data.quick_actions
                     if action.category == "system"
                 ],
-                
-                # Revolution zones
+
+                # OpenAPI Client groups
                 "zones_table": {
                     "headers": [
                         {"label": "Zone"},
@@ -209,7 +220,7 @@ class UnfoldCallbacks(
                         {"label": "Status"},
                         {"label": "Actions"},
                     ],
-                    "rows": self.get_revolution_zones_data()[0],
+                    "rows": OpenAPIClientCallbacks().get_openapi_groups_data()[0],
                 },
                 
                 # Recent users

django_cfg/modules/django_unfold/callbacks/revolution.py

@@ -1,5 +1,5 @@
 """
-Django Revolution integration callbacks.
+Django Client (OpenAPI) integration callbacks.
 """
 
 import logging
@@ -10,67 +10,72 @@ from django.conf import settings
 logger = logging.getLogger(__name__)
 
 
-class RevolutionCallbacks:
-    """Django Revolution integration callbacks."""
-    
-    def get_revolution_zones_data(self) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
-        """Get Django Revolution zones data."""
+class OpenAPIClientCallbacks:
+    """Django Client (OpenAPI) integration callbacks."""
+
+    def get_openapi_groups_data(self) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        """Get Django Client (OpenAPI) groups data."""
         try:
-            # Try to get revolution config from Django settings
-            revolution_config = getattr(settings, "DJANGO_REVOLUTION", {})
-            zones = revolution_config.get("zones", {})
-            api_prefix = revolution_config.get("api_prefix", "apix")
+            # Try to get openapi_client config from Django settings
+            openapi_config = getattr(settings, "OPENAPI_CLIENT", {})
+            if isinstance(openapi_config, dict):
+                groups_list = openapi_config.get("groups", [])
+                api_prefix = openapi_config.get("api_prefix", "api")
+            else:
+                # Handle Pydantic model instance
+                groups_list = getattr(openapi_config, "groups", [])
+                api_prefix = getattr(openapi_config, "api_prefix", "api")
 
-            zones_data = []
+            groups_data = []
             total_apps = 0
             total_endpoints = 0
 
-            for zone_name, zone_config in zones.items():
+            for group in groups_list:
                 # Handle both dict and object access
-                if isinstance(zone_config, dict):
-                    title = zone_config.get("title", zone_name.title())
-                    description = zone_config.get("description", f"{zone_name} zone")
-                    apps = zone_config.get("apps", [])
-                    public = zone_config.get("public", False)
-                    auth_required = zone_config.get("auth_required", True)
+                if isinstance(group, dict):
+                    group_name = group.get("name", "unknown")
+                    title = group.get("title", group_name.title())
+                    description = group.get("description", f"{group_name} group")
+                    apps = group.get("apps", [])
                 else:
-                    # Handle object access (for ZoneConfig instances)
-                    title = getattr(zone_config, "title", zone_name.title())
-                    description = getattr(zone_config, "description", f"{zone_name} zone")
-                    apps = getattr(zone_config, "apps", [])
-                    public = getattr(zone_config, "public", False)
-                    auth_required = getattr(zone_config, "auth_required", True)
+                    # Handle object access (for OpenAPIGroupConfig instances)
+                    group_name = getattr(group, "name", "unknown")
+                    title = getattr(group, "title", group_name.title())
+                    description = getattr(group, "description", f"{group_name} group")
+                    apps = getattr(group, "apps", [])
 
                 # Count actual endpoints by checking URL patterns (simplified estimate)
                 endpoint_count = len(apps) * 3  # Conservative estimate
 
-                zones_data.append({
-                    "name": zone_name,
+                groups_data.append({
+                    "name": group_name,
                     "title": title,
                     "description": description,
                     "app_count": len(apps),
                     "endpoint_count": endpoint_count,
                     "status": "active",
-                    "public": public,
-                    "auth_required": auth_required,
-                    "schema_url": f"/schema/{zone_name}/schema/",
-                    "swagger_url": f"/schema/{zone_name}/schema/swagger/",
-                    "redoc_url": f"/schema/{zone_name}/redoc/",
-                    "api_url": f"/{api_prefix}/{zone_name}/",
+                    "schema_url": f"/schema/{group_name}/",
+                    "swagger_url": f"/schema/{group_name}/swagger/",
+                    "redoc_url": f"/schema/{group_name}/redoc/",
+                    "api_url": f"/{api_prefix}/{group_name}/",
                 })
 
                 total_apps += len(apps)
                 total_endpoints += endpoint_count
 
-            return zones_data, {
+            return groups_data, {
                 "total_apps": total_apps,
                 "total_endpoints": total_endpoints,
-                "total_zones": len(zones),
+                "total_groups": len(groups_list),
             }
         except Exception as e:
-            logger.error(f"Error getting revolution zones: {e}")
+            logger.error(f"Error getting OpenAPI groups: {e}")
             return [], {
                 "total_apps": 0,
                 "total_endpoints": 0,
-                "total_zones": 0,
+                "total_groups": 0,
             }
+
+
+# Keep backward compatibility alias
+RevolutionCallbacks = OpenAPIClientCallbacks