django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/modules/django_app_agent/services/template_manager/templates/cfg_config.py.j2

@@ -0,0 +1,44 @@
+"""
+Django-CFG configuration for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django_cfg.config import BaseCfgConfig
+from pydantic import Field
+from typing import Optional, List
+
+
+class {{ app_name|pascal_case }}Config(BaseCfgConfig):
+    """Configuration for {{ app_name }} application."""
+    
+    # Basic settings
+    enabled: bool = Field(default=True, description="Enable {{ app_name }} functionality")
+    debug_mode: bool = Field(default=False, description="Enable debug mode for {{ app_name }}")
+    
+    # Feature toggles
+    {% if features.api %}
+    api_enabled: bool = Field(default=True, description="Enable API endpoints")
+    api_rate_limit: int = Field(default=100, description="API rate limit per hour")
+    {% endif %}
+    
+    {% if features.caching %}
+    cache_timeout: int = Field(default=300, description="Cache timeout in seconds")
+    cache_key_prefix: str = Field(default="{{ app_name }}", description="Cache key prefix")
+    {% endif %}
+    
+    {% if features.notifications %}
+    notifications_enabled: bool = Field(default=True, description="Enable notifications")
+    email_notifications: bool = Field(default=False, description="Send email notifications")
+    {% endif %}
+    
+    # Business logic settings
+    max_items_per_user: Optional[int] = Field(default=None, description="Maximum items per user")
+    allowed_file_types: List[str] = Field(
+        default=["jpg", "png", "pdf"], 
+        description="Allowed file upload types"
+    )
+    
+    class Meta:
+        app_name = "{{ app_name }}"
+        config_prefix = "{{ app_name|upper }}"

django_cfg/modules/django_app_agent/services/template_manager/templates/cfg_module.py.j2

@@ -0,0 +1,81 @@
+"""
+Django-CFG module for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django_cfg.modules import BaseCfgModule
+from django_cfg.decorators import cfg_module
+from .config import {{ app_name|pascal_case }}Config
+
+
+@cfg_module
+class {{ app_name|pascal_case }}Module(BaseCfgModule[{{ app_name|pascal_case }}Config]):
+    """Django-CFG module for {{ app_name }}."""
+    
+    config_class = {{ app_name|pascal_case }}Config
+    
+    def __init__(self):
+        """Initialize {{ app_name }} module."""
+        super().__init__()
+        self.name = "{{ app_name }}"
+        self.version = "1.0.0"
+        self.description = "{{ description }}"
+    
+    async def initialize(self):
+        """Initialize module resources."""
+        self.logger.info(f"Initializing {{ app_name }} module")
+        
+        {% if features.database_setup %}
+        # Setup database connections if needed
+        await self._setup_database()
+        {% endif %}
+        
+        {% if features.cache_setup %}
+        # Setup cache if needed
+        await self._setup_cache()
+        {% endif %}
+        
+        self.logger.info(f"{{ app_name|title_case }} module initialized successfully")
+    
+    async def cleanup(self):
+        """Cleanup module resources."""
+        self.logger.info(f"Cleaning up {{ app_name }} module")
+        
+        {% if features.cleanup_tasks %}
+        # Perform cleanup tasks
+        await self._cleanup_resources()
+        {% endif %}
+    
+    def get_health_status(self) -> dict:
+        """Get module health status."""
+        return {
+            "status": "healthy",
+            "module": self.name,
+            "version": self.version,
+            "config_loaded": self.config is not None,
+            {% if features.database_setup %}
+            "database_connected": self._check_database_connection(),
+            {% endif %}
+        }
+    
+    {% if features.database_setup %}
+    async def _setup_database(self):
+        """Setup database connections."""
+        # Implement database setup logic
+        pass
+    {% endif %}
+    
+    {% if features.cache_setup %}
+    async def _setup_cache(self):
+        """Setup cache connections."""
+        # Implement cache setup logic
+        pass
+    {% endif %}
+    
+    {% if features.cleanup_tasks %}
+    async def _cleanup_resources(self):
+        """Cleanup module resources."""
+        # Implement cleanup logic
+        pass
+    {% endif %}

django_cfg/modules/django_app_agent/services/template_manager/templates/forms.py.j2

@@ -0,0 +1,107 @@
+"""
+Forms for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django import forms
+from django.core.exceptions import ValidationError
+{% if features.crispy_forms %}
+from crispy_forms.helper import FormHelper
+from crispy_forms.layout import Layout, Submit, Row, Column
+{% endif %}
+from .models import {{ app_name|pascal_case }}Model
+
+
+class {{ app_name|pascal_case }}Form(forms.ModelForm):
+    """Form for {{ app_name }} model."""
+    
+    class Meta:
+        model = {{ app_name|pascal_case }}Model
+        fields = [
+            'name', 
+            'description',
+            {% if features.status_tracking %}'status',{% endif %}
+        ]
+        widgets = {
+            'description': forms.Textarea(attrs={'rows': 4}),
+            {% if features.status_tracking %}
+            'status': forms.Select(attrs={'class': 'form-select'}),
+            {% endif %}
+        }
+        help_texts = {
+            'name': 'Enter a descriptive name for this {{ app_name|singular }}',
+            'description': 'Provide additional details (optional)',
+        }
+    
+    {% if features.crispy_forms %}
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.helper = FormHelper()
+        self.helper.layout = Layout(
+            Row(
+                Column('name', css_class='form-group col-md-8 mb-0'),
+                {% if features.status_tracking %}
+                Column('status', css_class='form-group col-md-4 mb-0'),
+                {% endif %}
+                css_class='form-row'
+            ),
+            'description',
+            Submit('submit', 'Save {{ app_name|title_case }}', css_class='btn btn-primary')
+        )
+    {% endif %}
+    
+    def clean_name(self):
+        """Validate name field."""
+        name = self.cleaned_data.get('name')
+        if name:
+            # Check for duplicate names (case-insensitive)
+            existing = {{ app_name|pascal_case }}Model.objects.filter(
+                name__iexact=name
+            )
+            if self.instance.pk:
+                existing = existing.exclude(pk=self.instance.pk)
+            
+            if existing.exists():
+                raise ValidationError(
+                    f'A {{ app_name|singular }} with this name already exists.'
+                )
+        
+        return name
+    
+    def clean(self):
+        """Additional form validation."""
+        cleaned_data = super().clean()
+        
+        # Add any cross-field validation here
+        name = cleaned_data.get('name')
+        description = cleaned_data.get('description')
+        
+        if name and description and name.lower() in description.lower():
+            self.add_error('description', 
+                'Description should not just repeat the name.')
+        
+        return cleaned_data
+
+
+{% if features.search_forms %}
+class {{ app_name|pascal_case }}SearchForm(forms.Form):
+    """Search form for {{ app_name }}."""
+    
+    query = forms.CharField(
+        max_length=100,
+        required=False,
+        widget=forms.TextInput(attrs={
+            'placeholder': 'Search {{ app_name|plural }}...',
+            'class': 'form-control'
+        })
+    )
+    
+    {% if features.status_tracking %}
+    status = forms.ChoiceField(
+        choices=[('', 'All')] + {{ app_name|pascal_case }}Model.STATUS_CHOICES,
+        required=False,
+        widget=forms.Select(attrs={'class': 'form-select'})
+    )
+    {% endif %}
+{% endif %}

django_cfg/modules/django_app_agent/services/template_manager/templates/models.py.j2

@@ -0,0 +1,139 @@
+"""
+Models for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django.db import models
+from django.urls import reverse
+from django.core.validators import MinLengthValidator, MaxLengthValidator
+{% if app_type == 'django_cfg' %}
+from django_cfg.models import BaseCfgModel
+{% endif %}
+{% if features.user_relations %}
+from django.contrib.auth.models import User
+{% endif %}
+{% if features.uuid_primary_keys %}
+import uuid
+{% endif %}
+
+
+{% if app_type == 'django_cfg' %}
+class {{ app_name|pascal_case }}Model(BaseCfgModel):
+{% else %}
+class {{ app_name|pascal_case }}Model(models.Model):
+{% endif %}
+    """Main model for {{ app_name }} application."""
+    
+    {% if features.uuid_primary_keys %}
+    id = models.UUIDField(
+        primary_key=True,
+        default=uuid.uuid4,
+        editable=False,
+        help_text="Unique identifier"
+    )
+    {% endif %}
+    
+    name = models.CharField(
+        max_length=100,
+        validators=[MinLengthValidator(2)],
+        help_text="Name of the {{ app_name|singular|title_case }}"
+    )
+    
+    description = models.TextField(
+        blank=True,
+        help_text="Detailed description"
+    )
+    
+    {% if features.status_tracking %}
+    STATUS_CHOICES = [
+        ('draft', 'Draft'),
+        ('published', 'Published'),
+        ('archived', 'Archived'),
+    ]
+    
+    status = models.CharField(
+        max_length=20,
+        choices=STATUS_CHOICES,
+        default='draft',
+        help_text="Current status"
+    )
+    {% endif %}
+    
+    {% if features.user_relations %}
+    owner = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        related_name="{{ app_name }}_owned",
+        help_text="Owner of this {{ app_name|singular }}"
+    )
+    {% endif %}
+    
+    {% if not app_type == 'django_cfg' %}
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    {% endif %}
+    
+    class Meta:
+        verbose_name = "{{ app_name|singular|title_case }}"
+        verbose_name_plural = "{{ app_name|plural|title_case }}"
+        ordering = ['-created_at']
+        {% if features.database_indexes %}
+        indexes = [
+            models.Index(fields=['name']),
+            models.Index(fields=['created_at']),
+            {% if features.status_tracking %}
+            models.Index(fields=['status']),
+            {% endif %}
+        ]
+        {% endif %}
+    
+    def __str__(self):
+        return self.name
+    
+    def get_absolute_url(self):
+        return reverse('{{ app_name }}:detail', kwargs={'pk': self.pk})
+    
+    {% if features.custom_methods %}
+    def is_published(self):
+        """Check if the item is published."""
+        {% if features.status_tracking %}
+        return self.status == 'published'
+        {% else %}
+        return True
+        {% endif %}
+    
+    def get_display_name(self):
+        """Get formatted display name."""
+        return self.name.title()
+    {% endif %}
+
+
+{% if features.related_models %}
+class {{ app_name|pascal_case }}Category(models.Model):
+    """Category model for {{ app_name }}."""
+    
+    name = models.CharField(max_length=50, unique=True)
+    slug = models.SlugField(unique=True)
+    description = models.TextField(blank=True)
+    
+    class Meta:
+        verbose_name_plural = "Categories"
+        ordering = ['name']
+    
+    def __str__(self):
+        return self.name
+
+
+class {{ app_name|pascal_case }}Tag(models.Model):
+    """Tag model for {{ app_name }}."""
+    
+    name = models.CharField(max_length=30, unique=True)
+    color = models.CharField(max_length=7, default='#007bff')  # Hex color
+    
+    class Meta:
+        ordering = ['name']
+    
+    def __str__(self):
+        return self.name
+{% endif %}

django_cfg/modules/django_app_agent/services/template_manager/templates/serializers.py.j2

@@ -0,0 +1,91 @@
+"""
+DRF Serializers for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from rest_framework import serializers
+{% if features.nested_serializers %}
+from rest_framework.fields import SerializerMethodField
+{% endif %}
+from .models import {{ app_name|pascal_case }}Model
+{% if features.related_models %}
+from .models import {{ app_name|pascal_case }}Category, {{ app_name|pascal_case }}Tag
+{% endif %}
+
+
+class {{ app_name|pascal_case }}Serializer(serializers.ModelSerializer):
+    """Serializer for {{ app_name }} model."""
+    
+    {% if features.computed_fields %}
+    display_name = serializers.SerializerMethodField()
+    is_published = serializers.SerializerMethodField()
+    {% endif %}
+    
+    class Meta:
+        model = {{ app_name|pascal_case }}Model
+        fields = [
+            'id',
+            'name',
+            'description',
+            {% if features.status_tracking %}'status',{% endif %}
+            {% if features.user_relations %}'owner',{% endif %}
+            'created_at',
+            'updated_at',
+            {% if features.computed_fields %}
+            'display_name',
+            'is_published',
+            {% endif %}
+        ]
+        read_only_fields = ['id', 'created_at', 'updated_at']
+    
+    {% if features.computed_fields %}
+    def get_display_name(self, obj):
+        """Get formatted display name."""
+        return obj.get_display_name()
+    
+    def get_is_published(self, obj):
+        """Check if item is published."""
+        return obj.is_published()
+    {% endif %}
+    
+    def validate_name(self, value):
+        """Validate name field."""
+        if len(value.strip()) < 2:
+            raise serializers.ValidationError(
+                "Name must be at least 2 characters long."
+            )
+        return value.strip()
+
+
+{% if features.list_serializers %}
+class {{ app_name|pascal_case }}ListSerializer(serializers.ModelSerializer):
+    """Lightweight serializer for {{ app_name }} lists."""
+    
+    class Meta:
+        model = {{ app_name|pascal_case }}Model
+        fields = [
+            'id',
+            'name',
+            {% if features.status_tracking %}'status',{% endif %}
+            'created_at'
+        ]
+{% endif %}
+
+
+{% if features.related_models %}
+class {{ app_name|pascal_case }}CategorySerializer(serializers.ModelSerializer):
+    """Serializer for {{ app_name }} categories."""
+    
+    class Meta:
+        model = {{ app_name|pascal_case }}Category
+        fields = ['id', 'name', 'slug', 'description']
+
+
+class {{ app_name|pascal_case }}TagSerializer(serializers.ModelSerializer):
+    """Serializer for {{ app_name }} tags."""
+    
+    class Meta:
+        model = {{ app_name|pascal_case }}Tag
+        fields = ['id', 'name', 'color']
+{% endif %}

django_cfg/modules/django_app_agent/services/template_manager/templates/tests.py.j2

@@ -0,0 +1,195 @@
+"""
+Tests for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django.test import TestCase, Client
+from django.urls import reverse
+{% if features.user_relations %}
+from django.contrib.auth.models import User
+{% endif %}
+{% if features.api_tests %}
+from rest_framework.test import APITestCase
+from rest_framework import status
+{% endif %}
+from .models import {{ app_name|pascal_case }}Model
+
+
+class {{ app_name|pascal_case }}ModelTest(TestCase):
+    """Test cases for {{ app_name }} model."""
+    
+    def setUp(self):
+        """Set up test data."""
+        {% if features.user_relations %}
+        self.user = User.objects.create_user(
+            username='testuser',
+            email='test@example.com',
+            password='testpass123'
+        )
+        {% endif %}
+        
+        self.{{ app_name|snake_case }} = {{ app_name|pascal_case }}Model.objects.create(
+            name='Test {{ app_name|title_case }}',
+            description='Test description',
+            {% if features.status_tracking %}status='draft',{% endif %}
+            {% if features.user_relations %}owner=self.user{% endif %}
+        )
+    
+    def test_string_representation(self):
+        """Test string representation of model."""
+        self.assertEqual(str(self.{{ app_name|snake_case }}), 'Test {{ app_name|title_case }}')
+    
+    def test_get_absolute_url(self):
+        """Test get_absolute_url method."""
+        url = self.{{ app_name|snake_case }}.get_absolute_url()
+        expected_url = reverse('{{ app_name }}:detail', kwargs={'pk': self.{{ app_name|snake_case }}.pk})
+        self.assertEqual(url, expected_url)
+    
+    {% if features.custom_methods %}
+    def test_is_published(self):
+        """Test is_published method."""
+        {% if features.status_tracking %}
+        self.assertFalse(self.{{ app_name|snake_case }}.is_published())
+        
+        self.{{ app_name|snake_case }}.status = 'published'
+        self.{{ app_name|snake_case }}.save()
+        self.assertTrue(self.{{ app_name|snake_case }}.is_published())
+        {% else %}
+        self.assertTrue(self.{{ app_name|snake_case }}.is_published())
+        {% endif %}
+    
+    def test_get_display_name(self):
+        """Test get_display_name method."""
+        display_name = self.{{ app_name|snake_case }}.get_display_name()
+        self.assertEqual(display_name, 'Test {{ app_name|title_case }}')
+    {% endif %}
+
+
+{% if features.view_tests %}
+class {{ app_name|pascal_case }}ViewTest(TestCase):
+    """Test cases for {{ app_name }} views."""
+    
+    def setUp(self):
+        """Set up test data."""
+        self.client = Client()
+        {% if features.user_relations %}
+        self.user = User.objects.create_user(
+            username='testuser',
+            email='test@example.com',
+            password='testpass123'
+        )
+        {% endif %}
+        
+        self.{{ app_name|snake_case }} = {{ app_name|pascal_case }}Model.objects.create(
+            name='Test {{ app_name|title_case }}',
+            description='Test description',
+            {% if features.status_tracking %}status='published',{% endif %}
+            {% if features.user_relations %}owner=self.user{% endif %}
+        )
+    
+    {% if features.function_based_views %}
+    def test_index_view(self):
+        """Test index view."""
+        {% if features.authentication %}
+        self.client.login(username='testuser', password='testpass123')
+        {% endif %}
+        
+        url = reverse('{{ app_name }}:index')
+        response = self.client.get(url)
+        
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, 'Test {{ app_name|title_case }}')
+    
+    def test_detail_view(self):
+        """Test detail view."""
+        {% if features.authentication %}
+        self.client.login(username='testuser', password='testpass123')
+        {% endif %}
+        
+        url = reverse('{{ app_name }}:detail', kwargs={'pk': self.{{ app_name|snake_case }}.pk})
+        response = self.client.get(url)
+        
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.{{ app_name|snake_case }}.name)
+    {% endif %}
+    
+    {% if features.class_based_views %}
+    def test_list_view(self):
+        """Test list view."""
+        {% if features.authentication %}
+        self.client.login(username='testuser', password='testpass123')
+        {% endif %}
+        
+        url = reverse('{{ app_name }}:list')
+        response = self.client.get(url)
+        
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.{{ app_name|snake_case }}.name)
+    {% endif %}
+    
+    {% if features.crud_views %}
+    def test_create_view(self):
+        """Test create view."""
+        {% if features.authentication %}
+        self.client.login(username='testuser', password='testpass123')
+        {% endif %}
+        
+        url = reverse('{{ app_name }}:create')
+        
+        # Test GET request
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        
+        # Test POST request
+        data = {
+            'name': 'New {{ app_name|title_case }}',
+            'description': 'New description',
+            {% if features.status_tracking %}'status': 'draft'{% endif %}
+        }
+        response = self.client.post(url, data)
+        self.assertEqual(response.status_code, 302)  # Redirect after success
+        
+        # Verify object was created
+        self.assertTrue(
+            {{ app_name|pascal_case }}Model.objects.filter(name='New {{ app_name|title_case }}').exists()
+        )
+    {% endif %}
+{% endif %}
+
+
+{% if features.api_tests %}
+class {{ app_name|pascal_case }}APITest(APITestCase):
+    """Test cases for {{ app_name }} API."""
+    
+    def setUp(self):
+        """Set up test data."""
+        {% if features.user_relations %}
+        self.user = User.objects.create_user(
+            username='testuser',
+            email='test@example.com',
+            password='testpass123'
+        )
+        {% endif %}
+        
+        self.{{ app_name|snake_case }} = {{ app_name|pascal_case }}Model.objects.create(
+            name='Test {{ app_name|title_case }}',
+            description='Test description',
+            {% if features.status_tracking %}status='published',{% endif %}
+            {% if features.user_relations %}owner=self.user{% endif %}
+        )
+    
+    def test_api_view(self):
+        """Test API view."""
+        {% if features.authentication %}
+        self.client.force_authenticate(user=self.user)
+        {% endif %}
+        
+        url = reverse('{{ app_name }}:api')
+        response = self.client.get(url)
+        
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertTrue(response.data['success'])
+        self.assertEqual(len(response.data['data']), 1)
+        self.assertEqual(response.data['data'][0]['name'], 'Test {{ app_name|title_case }}')
+{% endif %}

django_cfg/modules/django_app_agent/services/template_manager/templates/urls.py.j2

@@ -0,0 +1,35 @@
+"""
+URL configuration for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django.urls import path, include
+{% if features.api_views %}
+from django.urls import re_path
+{% endif %}
+from . import views
+
+app_name = '{{ app_name }}'
+
+urlpatterns = [
+    {% if features.function_based_views %}
+    path('', views.{{ app_name }}_index, name='index'),
+    path('<int:pk>/', views.{{ app_name }}_detail, name='detail'),
+    {% endif %}
+    
+    {% if features.class_based_views %}
+    path('list/', views.{{ app_name|pascal_case }}ListView.as_view(), name='list'),
+    path('detail/<int:pk>/', views.{{ app_name|pascal_case }}DetailView.as_view(), name='detail'),
+    
+    {% if features.crud_views %}
+    path('create/', views.{{ app_name|pascal_case }}CreateView.as_view(), name='create'),
+    path('update/<int:pk>/', views.{{ app_name|pascal_case }}UpdateView.as_view(), name='update'),
+    path('delete/<int:pk>/', views.{{ app_name|pascal_case }}DeleteView.as_view(), name='delete'),
+    {% endif %}
+    {% endif %}
+    
+    {% if features.api_views %}
+    path('api/', views.{{ app_name|pascal_case }}APIView.as_view(), name='api'),
+    {% endif %}
+]