django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/modules/django_client/management/commands/generate_client.py

@@ -14,7 +14,7 @@ from django.core.management.base import BaseCommand, CommandError
 class Command(BaseCommand):
     """Generate OpenAPI clients for configured application groups."""
 
-    help = "Generate Python and TypeScript API clients from OpenAPI schemas"
+    help = "Generate Python, TypeScript, and Go API clients from OpenAPI schemas"
 
     def add_arguments(self, parser):
         """Add command arguments."""
@@ -37,6 +37,18 @@ class Command(BaseCommand):
             help="Generate TypeScript client only",
         )
 
+        parser.add_argument(
+            "--go",
+            action="store_true",
+            help="Generate Go client only",
+        )
+
+        parser.add_argument(
+            "--proto",
+            action="store_true",
+            help="Generate Protocol Buffer/gRPC definitions only",
+        )
+
         parser.add_argument(
             "--no-python",
             action="store_true",
@@ -49,7 +61,25 @@ class Command(BaseCommand):
             help="Skip TypeScript client generation",
         )
 
+        parser.add_argument(
+            "--no-go",
+            action="store_true",
+            help="Skip Go client generation",
+        )
+
+        parser.add_argument(
+            "--no-proto",
+            action="store_true",
+            help="Skip Protocol Buffer generation",
+        )
+
         # Utility options
+        parser.add_argument(
+            "--no-build",
+            action="store_true",
+            help="Skip Next.js admin build (useful when calling from Makefile)",
+        )
+
         parser.add_argument(
             "--dry-run",
             action="store_true",
@@ -193,15 +223,31 @@ class Command(BaseCommand):
     def _generate_clients(self, service, options):
         """Generate clients."""
         # Determine languages
-        if options["python"] and not options["typescript"]:
+        if options["python"] and not options["typescript"] and not options["go"] and not options["proto"]:
             python = True
             typescript = False
-        elif options["typescript"] and not options["python"]:
+            go = False
+            proto = False
+        elif options["typescript"] and not options["python"] and not options["go"] and not options["proto"]:
             python = False
             typescript = True
+            go = False
+            proto = False
+        elif options["go"] and not options["python"] and not options["typescript"] and not options["proto"]:
+            python = False
+            typescript = False
+            go = True
+            proto = False
+        elif options["proto"] and not options["python"] and not options["typescript"] and not options["go"]:
+            python = False
+            typescript = False
+            go = False
+            proto = True
         else:
             python = not options["no_python"]
             typescript = not options["no_typescript"]
+            go = not options["no_go"]
+            proto = not options["no_proto"]
 
         # Get groups
         groups = options.get("groups")
@@ -233,6 +279,10 @@ class Command(BaseCommand):
             self.stdout.write("  → Python")
         if typescript:
             self.stdout.write("  → TypeScript")
+        if go:
+            self.stdout.write("  → Go")
+        if proto:
+            self.stdout.write("  → Protocol Buffers (proto3)")
 
         if dry_run:
             self.stdout.write(self.style.WARNING("\n✅ Dry run completed - no files generated"))
@@ -248,7 +298,9 @@ class Command(BaseCommand):
 
         from django_cfg.modules.django_client.core import (
             ArchiveManager,
+            GoGenerator,
             GroupManager,
+            ProtoGenerator,
             PythonGenerator,
             TypeScriptGenerator,
             parse_openapi,
@@ -395,6 +447,53 @@ class Command(BaseCommand):
 
                     self.stdout.write(f"  ✅ TypeScript client: {ts_dir} ({len(ts_files)} files)")
 
+                # Generate Go client
+                if go:
+                    self.stdout.write("  → Generating Go client...")
+                    go_dir = service.config.get_group_go_dir(group_name)
+                    go_dir.mkdir(parents=True, exist_ok=True)
+
+                    go_generator = GoGenerator(
+                        ir_context,
+                        client_structure=service.config.client_structure,
+                        openapi_schema=schema_dict,
+                        tag_prefix=f"{group_name}_",
+                        generate_package_files=service.config.generate_package_files,
+                        package_config={
+                            "name": group_name,
+                            "module_name": group_name,
+                            "version": "v1.0.0",
+                        },
+                    )
+                    go_files = go_generator.generate()
+
+                    for generated_file in go_files:
+                        full_path = go_dir / generated_file.path
+                        full_path.parent.mkdir(parents=True, exist_ok=True)
+                        full_path.write_text(generated_file.content)
+
+                    self.stdout.write(f"  ✅ Go client: {go_dir} ({len(go_files)} files)")
+
+                # Generate Proto files
+                if proto:
+                    self.stdout.write("  → Generating Protocol Buffer definitions...")
+                    proto_dir = clients_dir / "proto" / group_name
+                    proto_dir.mkdir(parents=True, exist_ok=True)
+
+                    proto_generator = ProtoGenerator(
+                        ir_context,
+                        split_files=True,  # Generate separate messages.proto and services.proto
+                        package_name=f"{group_name}.v1",
+                    )
+                    proto_files = proto_generator.generate()
+
+                    for generated_file in proto_files:
+                        full_path = proto_dir / generated_file.path
+                        full_path.parent.mkdir(parents=True, exist_ok=True)
+                        full_path.write_text(generated_file.content)
+
+                    self.stdout.write(f"  ✅ Proto files: {proto_dir} ({len(proto_files)} files)")
+
                 # Archive if enabled
                 if service.config.enable_archive:
                     self.stdout.write("  → Archiving...")
@@ -403,6 +502,8 @@ class Command(BaseCommand):
                         group_name,
                         python_dir=service.config.get_group_python_dir(group_name) if python else None,
                         typescript_dir=service.config.get_group_typescript_dir(group_name) if typescript else None,
+                        go_dir=go_dir if go else None,
+                        proto_dir=proto_dir if proto else None,
                     )
                     if archive_result.get('success'):
                         self.stdout.write(f"  ✅ Archived: {archive_result['archive_path']}")
@@ -415,6 +516,19 @@ class Command(BaseCommand):
                 import traceback
                 traceback.print_exc()
 
+        # Build and copy to Next.js admin (if configured)
+        if typescript and success_count > 0:
+            # First copy API clients
+            self._copy_to_nextjs_admin(service)
+            # Then build Next.js (so clients are included in build)
+            # Skip build if --no-build flag is set
+            if not options.get("no_build"):
+                self._build_nextjs_admin()
+            else:
+                self.stdout.write(self.style.WARNING(
+                    "\n⏭️  Skipping Next.js build (--no-build flag set)"
+                ))
+
         # Summary
         self.stdout.write("\n" + "=" * 60)
         if error_count == 0:
@@ -428,3 +542,238 @@ class Command(BaseCommand):
             self.stdout.write(f"  Python:     {service.config.get_python_clients_dir()}")
         if typescript:
             self.stdout.write(f"  TypeScript: {service.config.get_typescript_clients_dir()}")
+        if go:
+            self.stdout.write(f"  Go:         {service.config.get_go_clients_dir()}")
+
+    def _copy_to_nextjs_admin(self, service):
+        """Copy TypeScript clients to Next.js admin project (if configured)."""
+        try:
+            from django_cfg.core.config import get_current_config
+            from pathlib import Path
+            import shutil
+
+            config = get_current_config()
+            if not config or not config.nextjs_admin:
+                return
+
+            nextjs_config = config.nextjs_admin
+            if not nextjs_config.auto_copy_api:
+                return
+
+            # Resolve Next.js project path
+            base_dir = config.base_dir
+            project_path = Path(nextjs_config.project_path)
+            if not project_path.is_absolute():
+                project_path = base_dir / project_path
+
+            if not project_path.exists():
+                self.stdout.write(self.style.WARNING(
+                    f"\n⚠️  Next.js project not found: {project_path}"
+                ))
+                return
+
+            # Resolve API output path
+            api_output_path = project_path / nextjs_config.get_api_output_path()
+
+            # Source: TypeScript clients directory
+            ts_source = service.config.get_typescript_clients_dir()
+
+            if not ts_source.exists():
+                return
+
+            self.stdout.write(f"\n📦 Copying TypeScript clients to Next.js admin...")
+
+            # Copy each group (exclude 'cfg' for Next.js admin)
+            copied_count = 0
+            for group_dir in ts_source.iterdir():
+                if not group_dir.is_dir():
+                    continue
+
+                group_name = group_dir.name
+
+                # Skip 'cfg' group for Next.js admin
+                if group_name == 'cfg':
+                    self.stdout.write(f"  ⏭️  Skipping 'cfg' group (excluded from Next.js admin)")
+                    continue
+
+                target_dir = api_output_path / group_name
+
+                # Remove old
+                if target_dir.exists():
+                    shutil.rmtree(target_dir)
+
+                # Copy new
+                shutil.copytree(group_dir, target_dir)
+                copied_count += 1
+
+                self.stdout.write(f"  ✅ {group_name} → {target_dir.relative_to(project_path)}")
+
+            if copied_count > 0:
+                self.stdout.write(self.style.SUCCESS(
+                    f"\n✅ Copied {copied_count} group(s) to Next.js admin!"
+                ))
+
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"\n❌ Failed to copy to Next.js admin: {e}"))
+            import traceback
+            traceback.print_exc()
+
+    def _build_nextjs_admin(self):
+        """Build Next.js admin static export (if configured)."""
+        try:
+            from django_cfg.core.config import get_current_config
+            from pathlib import Path
+            import subprocess
+            import shutil
+
+            config = get_current_config()
+            if not config or not config.nextjs_admin:
+                return
+
+            nextjs_config = config.nextjs_admin
+            if not nextjs_config.auto_build:
+                return
+
+            # Resolve Next.js project path
+            base_dir = config.base_dir
+            project_path = Path(nextjs_config.project_path)
+            if not project_path.is_absolute():
+                project_path = base_dir / project_path
+
+            if not project_path.exists():
+                self.stdout.write(self.style.WARNING(
+                    f"\n⚠️  Next.js project not found: {project_path}"
+                ))
+                return
+
+            self.stdout.write(f"\n🏗️  Building Next.js admin static export...")
+
+            # Check if pnpm is available
+            pnpm_path = shutil.which('pnpm')
+            if not pnpm_path:
+                self.stdout.write(self.style.WARNING(
+                    "\n⚠️  pnpm not found. Skipping Next.js build."
+                ))
+                self.stdout.write("   Install pnpm or set auto_build=False in NextJsAdminConfig")
+                return
+
+            # Run pnpm build with NEXT_PUBLIC_STATIC_BUILD=true for static export
+            try:
+                import os
+                env = os.environ.copy()
+                env['NEXT_PUBLIC_STATIC_BUILD'] = 'true'
+
+                result = subprocess.run(
+                    [pnpm_path, 'build'],
+                    cwd=str(project_path),
+                    capture_output=True,
+                    text=True,
+                    timeout=300,  # 5 minutes timeout
+                    env=env,
+                )
+
+                if result.returncode == 0:
+                    self.stdout.write(self.style.SUCCESS(
+                        f"\n✅ Next.js admin built successfully!"
+                    ))
+
+                    # Check build output
+                    static_output = project_path / nextjs_config.get_static_output_path()
+                    if static_output.exists():
+                        self.stdout.write(self.style.SUCCESS(
+                            f"   📁 Build output: {static_output.relative_to(base_dir)}"
+                        ))
+
+                        # Create ZIP archive for Django static (Docker-ready)
+                        # Use solution project's BASE_DIR from Django settings
+                        from django.conf import settings as django_settings
+                        solution_base_dir = django_settings.BASE_DIR
+
+                        django_static_zip = nextjs_config.get_static_zip_path(solution_base_dir)
+
+                        try:
+                            # Ensure static directory exists
+                            django_static_zip.parent.mkdir(parents=True, exist_ok=True)
+
+                            # Remove old ZIP if exists
+                            if django_static_zip.exists():
+                                django_static_zip.unlink()
+
+                            # Check if zip command is available
+                            zip_path = shutil.which('zip')
+                            if not zip_path:
+                                self.stdout.write(self.style.WARNING(
+                                    "   ⚠️  zip command not found. Falling back to Python zipfile..."
+                                ))
+                                # Fallback to Python zipfile
+                                import zipfile
+                                with zipfile.ZipFile(django_static_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                                    for file_path in static_output.rglob('*'):
+                                        if file_path.is_file():
+                                            arcname = file_path.relative_to(static_output)
+                                            zipf.write(file_path, arcname)
+                            else:
+                                # Use system zip command (faster)
+                                subprocess.run(
+                                    [zip_path, '-r', '-q', str(django_static_zip), '.'],
+                                    cwd=str(static_output),
+                                    check=True
+                                )
+
+                            # Get ZIP size
+                            zip_size_mb = django_static_zip.stat().st_size / (1024 * 1024)
+
+                            # Show relative path from solution BASE_DIR
+                            relative_zip_path = django_static_zip.relative_to(solution_base_dir)
+
+                            self.stdout.write(self.style.SUCCESS(
+                                f"   ✅ Created ZIP archive: {relative_zip_path} ({zip_size_mb:.1f}MB)"
+                            ))
+                            self.stdout.write(self.style.SUCCESS(
+                                f"   📍 ZIP location: {django_static_zip}"
+                            ))
+                            self.stdout.write(self.style.SUCCESS(
+                                "   ℹ️  This ZIP is used by NextJsAdminView (Tab 2: External Admin)"
+                            ))
+
+                        except Exception as zip_error:
+                            self.stdout.write(self.style.ERROR(
+                                f"   ❌ Failed to create ZIP archive: {zip_error}"
+                            ))
+                    else:
+                        self.stdout.write(self.style.WARNING(
+                            f"   ⚠️  Build output not found at: {static_output.relative_to(base_dir)}"
+                        ))
+                else:
+                    self.stdout.write(self.style.ERROR(
+                        f"\n❌ Next.js build failed with exit code {result.returncode}"
+                    ))
+
+                    # Show full error output
+                    if result.stderr:
+                        self.stdout.write(self.style.ERROR(f"\n   stderr:\n{result.stderr}"))
+                    if result.stdout:
+                        self.stdout.write(self.style.ERROR(f"\n   stdout:\n{result.stdout}"))
+
+                    # Exit on build failure
+                    raise CommandError(
+                        f"Next.js build failed with exit code {result.returncode}. "
+                        "Fix the build errors and try again."
+                    )
+
+            except subprocess.TimeoutExpired:
+                self.stdout.write(self.style.ERROR(
+                    "\n❌ Next.js build timed out (5 minutes)"
+                ))
+                raise CommandError("Next.js build timed out after 5 minutes")
+
+            except Exception as build_error:
+                self.stdout.write(self.style.ERROR(
+                    f"\n❌ Build command failed: {build_error}"
+                ))
+                raise CommandError(f"Next.js build command failed: {build_error}")
+
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"\n❌ Failed to build Next.js admin: {e}"))
+            import traceback
+            traceback.print_exc()

django_cfg/modules/django_currency/examples/example_database_usage.py

@@ -63,7 +63,7 @@ def example_django_integration():
     print("""
     # In your Django management command or view:
     from django_cfg.modules.django_currency.database_loader import load_currencies_to_database_format
-    from django_cfg.apps.payments.models import Currency
+    from django_cfg.apps.business.payments.models import Currency
     
     # Load currency data
     currency_data = load_currencies_to_database_format()

django_cfg/modules/django_import_export/README.md

@@ -74,8 +74,26 @@ The module automatically works with:
 - Django-cfg configuration system
 - All original django-import-export features
 
+## Custom Templates
+
+This module includes custom templates for proper Unfold integration:
+
+### Button Styling
+- Import/Export buttons are styled as round icon buttons matching Unfold's design
+- Import button: Green with upload icon
+- Export button: Blue with download icon
+- Positioned next to the "Add" button in the admin interface
+
+### Template Locations
+Templates are located in `templates/admin/import_export/`:
+- `change_list_import_export.html` - For both import and export
+- `change_list_import.html` - Import only
+- `change_list_export.html` - Export only
+- `change_list_import_item.html` - Import button template
+- `change_list_export_item.html` - Export button template
+
 ## Full Documentation
 
 For complete documentation, see the official [django-import-export docs](https://django-import-export.readthedocs.io/).
 
-This module adds no additional functionality - it's purely for convenience and consistency within the django-cfg ecosystem.
+This module adds custom Unfold-styled templates for better visual integration with the admin interface.

django_cfg/modules/django_import_export/__init__.py

@@ -22,6 +22,14 @@ class ImportExportMixin(BaseImportExportMixin):
     import_form_class = ImportForm
     export_form_class = ExportForm
 
+    def changelist_view(self, request, extra_context=None):
+        """Add import/export permissions to context."""
+        if extra_context is None:
+            extra_context = {}
+        extra_context['has_import_permission'] = self.has_import_permission(request)
+        extra_context['has_export_permission'] = self.has_export_permission(request)
+        return super().changelist_view(request, extra_context)
+
 
 class ImportExportModelAdmin(BaseImportExportModelAdmin):
     """Django-CFG enhanced ImportExportModelAdmin with custom templates and Unfold forms."""

django_cfg/modules/django_import_export/apps.py

@@ -0,0 +1,16 @@
+from django.apps import AppConfig
+
+
+class DjangoImportExportConfig(AppConfig):
+    """Django Import/Export integration app configuration."""
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.modules.django_import_export'
+    label = 'django_cfg_import_export'
+    verbose_name = 'Django Import/Export Integration'
+
+    def ready(self):
+        """Initialize module classes when Django is ready."""
+        # Import and setup classes here to avoid AppRegistryNotReady
+        from . import _setup_classes
+        _setup_classes()

django_cfg/modules/django_import_export/templates/admin/import_export/change_list_export.html

@@ -0,0 +1,6 @@
+{% extends "admin/change_list.html" %}
+
+{% block object-tools-items %}
+    {{ block.super }}
+    {% include "admin/import_export/change_list_export_item.html" %}
+{% endblock %}

django_cfg/modules/django_import_export/templates/admin/import_export/change_list_export_item.html

@@ -0,0 +1,7 @@
+{% load admin_urls i18n %}
+
+{% if has_export_permission %}
+    <a href="export/{{ cl.get_query_string }}" class="bg-blue-600 flex items-center h-9 justify-center -my-1 rounded-full w-9 hover:bg-blue-700" title="{% trans 'Export' %}">
+        <span class="material-symbols-outlined text-white">download</span>
+    </a>
+{% endif %}

django_cfg/modules/django_import_export/templates/admin/import_export/change_list_import.html

@@ -0,0 +1,6 @@
+{% extends "admin/change_list.html" %}
+
+{% block object-tools-items %}
+    {{ block.super }}
+    {% include "admin/import_export/change_list_import_item.html" %}
+{% endblock %}

django_cfg/modules/django_import_export/templates/admin/import_export/change_list_import_export.html

@@ -0,0 +1,39 @@
+{% extends "admin/change_list.html" %}
+
+{% block extrahead %}
+    {{ block.super }}
+    <style>
+        /* Object Tools - Admin toolbar buttons */
+        .object-tools {
+            display: flex !important;
+            gap: 1rem !important; /* 16px gap between groups */
+            align-items: center !important;
+        }
+
+        /* Remove extra spacing from individual object-tools items */
+        .object-tools > * {
+            margin: 0 !important;
+        }
+
+        /* Import/Export button group */
+        .import-export-group {
+            display: flex !important;
+            gap: 0.5rem !important; /* 8px gap between import/export buttons */
+            align-items: center !important;
+        }
+
+        /* Separator before import/export group */
+        .import-export-separator {
+            margin: 0 0.5rem !important; /* 8px margin on each side */
+        }
+    </style>
+{% endblock %}
+
+{% block object-tools-items %}
+    {{ block.super }}
+    <span class="block bg-base-200 h-5 w-px dark:bg-base-700 import-export-separator"></span>
+    <div class="import-export-group">
+        {% include "admin/import_export/change_list_import_item.html" %}
+        {% include "admin/import_export/change_list_export_item.html" %}
+    </div>
+{% endblock %}

django_cfg/modules/django_import_export/templates/admin/import_export/change_list_import_item.html

@@ -0,0 +1,7 @@
+{% load admin_urls i18n %}
+
+{% if has_import_permission %}
+    <a href="import/" class="bg-green-600 flex items-center h-9 justify-center -my-1 rounded-full w-9 hover:bg-green-700" title="{% trans 'Import' %}">
+        <span class="material-symbols-outlined text-white">upload</span>
+    </a>
+{% endif %}

django_cfg/modules/django_logging/__init__.py

@@ -7,6 +7,7 @@ Auto-configuring logging utilities.
 from .django_logger import (
     RESERVED_LOG_ATTRS,
     DjangoLogger,
+    clean_old_logs,
     get_logger,
     sanitize_extra,
 )
@@ -17,5 +18,6 @@ __all__ = [
     "DjangoLogger",
     "get_logger",
     "sanitize_extra",
+    "clean_old_logs",
     "RESERVED_LOG_ATTRS",
 ]