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

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

@@ -0,0 +1,211 @@
+"""
+Views for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django.shortcuts import render, get_object_or_404, redirect
+from django.http import HttpResponse, JsonResponse, Http404
+from django.views.generic import (
+    ListView, DetailView, CreateView, UpdateView, DeleteView, TemplateView
+)
+from django.contrib import messages
+from django.urls import reverse_lazy
+{% if features.authentication %}
+from django.contrib.auth.decorators import login_required
+from django.contrib.auth.mixins import LoginRequiredMixin
+{% endif %}
+{% if features.permissions %}
+from django.contrib.auth.mixins import PermissionRequiredMixin
+{% endif %}
+{% if features.forms %}
+from .forms import {{ app_name|pascal_case }}Form
+{% endif %}
+from .models import {{ app_name|pascal_case }}Model
+
+
+{% if features.function_based_views %}
+{% if features.authentication %}
+@login_required
+{% endif %}
+def {{ app_name }}_index(request):
+    """Index view for {{ app_name }}."""
+    items = {{ app_name|pascal_case }}Model.objects.all()
+    {% if features.status_tracking %}
+    items = items.filter(status='published')
+    {% endif %}
+    
+    context = {
+        'items': items,
+        'app_name': '{{ app_name|title_case }}',
+        'description': '{{ description }}'
+    }
+    return render(request, '{{ app_name }}/index.html', context)
+
+
+{% if features.authentication %}
+@login_required
+{% endif %}
+def {{ app_name }}_detail(request, pk):
+    """Detail view for {{ app_name }}."""
+    item = get_object_or_404({{ app_name|pascal_case }}Model, pk=pk)
+    
+    {% if features.status_tracking and features.authentication %}
+    # Only show published items to non-owners
+    if item.status != 'published' and item.owner != request.user:
+        raise Http404("Item not found")
+    {% endif %}
+    
+    context = {
+        'item': item,
+        'app_name': '{{ app_name|title_case }}'
+    }
+    return render(request, '{{ app_name }}/detail.html', context)
+{% endif %}
+
+
+{% if features.class_based_views %}
+class {{ app_name|pascal_case }}ListView(
+    {%- if features.authentication %}LoginRequiredMixin, {% endif -%}
+    ListView
+):
+    """List view for {{ app_name }} items."""
+    
+    model = {{ app_name|pascal_case }}Model
+    template_name = '{{ app_name }}/list.html'
+    context_object_name = 'items'
+    paginate_by = 20
+    
+    {% if features.status_tracking %}
+    def get_queryset(self):
+        """Filter published items."""
+        queryset = super().get_queryset()
+        {% if features.authentication %}
+        if self.request.user.is_authenticated:
+            return queryset  # Show all to authenticated users
+        {% endif %}
+        return queryset.filter(status='published')
+    {% endif %}
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context['app_name'] = '{{ app_name|title_case }}'
+        return context
+
+
+class {{ app_name|pascal_case }}DetailView(
+    {%- if features.authentication %}LoginRequiredMixin, {% endif -%}
+    DetailView
+):
+    """Detail view for {{ app_name }} items."""
+    
+    model = {{ app_name|pascal_case }}Model
+    template_name = '{{ app_name }}/detail.html'
+    context_object_name = 'item'
+
+
+{% if features.crud_views %}
+class {{ app_name|pascal_case }}CreateView(
+    {%- if features.authentication %}LoginRequiredMixin, {% endif -%}
+    {%- if features.permissions %}PermissionRequiredMixin, {% endif -%}
+    CreateView
+):
+    """Create view for {{ app_name }} items."""
+    
+    model = {{ app_name|pascal_case }}Model
+    {% if features.forms %}
+    form_class = {{ app_name|pascal_case }}Form
+    {% else %}
+    fields = ['name', 'description'{% if features.status_tracking %}, 'status'{% endif %}]
+    {% endif %}
+    template_name = '{{ app_name }}/form.html'
+    success_url = reverse_lazy('{{ app_name }}:list')
+    {% if features.permissions %}
+    permission_required = '{{ app_name }}.add_{{ app_name|snake_case }}model'
+    {% endif %}
+    
+    {% if features.user_relations %}
+    def form_valid(self, form):
+        form.instance.owner = self.request.user
+        messages.success(self.request, f'{{ app_name|title_case }} created successfully!')
+        return super().form_valid(form)
+    {% endif %}
+
+
+class {{ app_name|pascal_case }}UpdateView(
+    {%- if features.authentication %}LoginRequiredMixin, {% endif -%}
+    {%- if features.permissions %}PermissionRequiredMixin, {% endif -%}
+    UpdateView
+):
+    """Update view for {{ app_name }} items."""
+    
+    model = {{ app_name|pascal_case }}Model
+    {% if features.forms %}
+    form_class = {{ app_name|pascal_case }}Form
+    {% else %}
+    fields = ['name', 'description'{% if features.status_tracking %}, 'status'{% endif %}]
+    {% endif %}
+    template_name = '{{ app_name }}/form.html'
+    {% if features.permissions %}
+    permission_required = '{{ app_name }}.change_{{ app_name|snake_case }}model'
+    {% endif %}
+    
+    def form_valid(self, form):
+        messages.success(self.request, f'{{ app_name|title_case }} updated successfully!')
+        return super().form_valid(form)
+
+
+class {{ app_name|pascal_case }}DeleteView(
+    {%- if features.authentication %}LoginRequiredMixin, {% endif -%}
+    {%- if features.permissions %}PermissionRequiredMixin, {% endif -%}
+    DeleteView
+):
+    """Delete view for {{ app_name }} items."""
+    
+    model = {{ app_name|pascal_case }}Model
+    template_name = '{{ app_name }}/confirm_delete.html'
+    success_url = reverse_lazy('{{ app_name }}:list')
+    {% if features.permissions %}
+    permission_required = '{{ app_name }}.delete_{{ app_name|snake_case }}model'
+    {% endif %}
+    
+    def delete(self, request, *args, **kwargs):
+        messages.success(request, f'{{ app_name|title_case }} deleted successfully!')
+        return super().delete(request, *args, **kwargs)
+{% endif %}
+{% endif %}
+
+
+{% if features.api_views %}
+class {{ app_name|pascal_case }}APIView(
+    {%- if features.authentication %}LoginRequiredMixin, {% endif -%}
+    TemplateView
+):
+    """API view for {{ app_name }}."""
+    
+    def get(self, request, *args, **kwargs):
+        """Get {{ app_name }} data as JSON."""
+        items = {{ app_name|pascal_case }}Model.objects.all()
+        {% if features.status_tracking %}
+        items = items.filter(status='published')
+        {% endif %}
+        
+        data = [
+            {
+                'id': item.pk,
+                'name': item.name,
+                'description': item.description,
+                {% if features.status_tracking %}
+                'status': item.status,
+                {% endif %}
+                'created_at': item.created_at.isoformat(),
+            }
+            for item in items[:50]  # Limit to 50 items
+        ]
+        
+        return JsonResponse({
+            'success': True,
+            'data': data,
+            'count': len(data)
+        })
+{% endif %}

django_cfg/modules/django_app_agent/services/template_manager/variable_processor.py

@@ -0,0 +1,200 @@
+"""
+Variable Processor for Template Manager.
+
+This module handles processing and enrichment of template variables
+based on app features and context.
+"""
+
+from typing import Dict, Any, List, Set
+import re
+
+from pydantic import BaseModel, Field
+
+from ...models.enums import AppType, AppFeature
+from ...models.requests import TemplateRequest
+from ..base import ServiceDependencies
+
+
+class VariableProcessor(BaseModel):
+    """Processes and enriches template variables."""
+    
+    def __init__(self, **data):
+        """Initialize variable processor."""
+        super().__init__(**data)
+    
+    async def process_variables(
+        self,
+        request: TemplateRequest,
+        dependencies: ServiceDependencies
+    ) -> Dict[str, Any]:
+        """Process and enrich template variables."""
+        # Start with provided variables
+        variables = dict(request.variables)
+        
+        # Add standard variables
+        variables.update(self._get_standard_variables(request))
+        
+        # Add feature-based variables
+        variables.update(self._get_feature_variables(request))
+        
+        # Add computed variables
+        variables.update(self._get_computed_variables(request, variables))
+        
+        dependencies.log_operation(
+            "Variables processed",
+            total_variables=len(variables),
+            standard_vars=len(self._get_standard_variables(request)),
+            feature_vars=len(self._get_feature_variables(request))
+        )
+        
+        return variables
+    
+    def _get_standard_variables(self, request: TemplateRequest) -> Dict[str, Any]:
+        """Get standard template variables."""
+        app_name = request.variables.get('app_name', 'myapp')
+        description = request.variables.get('description', f'Django application: {app_name}')
+        
+        return {
+            'app_name': app_name,
+            'description': description,
+            'app_type': request.app_type if isinstance(request.app_type, str) else request.app_type.value,
+            'features': {(f.value if hasattr(f, 'value') else f): True for f in request.features},
+            
+            # Name variations
+            'app_name_snake': self._to_snake_case(app_name),
+            'app_name_camel': self._to_camel_case(app_name),
+            'app_name_pascal': self._to_pascal_case(app_name),
+            'app_name_kebab': self._to_kebab_case(app_name),
+            'app_name_title': self._to_title_case(app_name),
+            
+            # Pluralization
+            'app_name_plural': self._pluralize(app_name),
+            'app_name_singular': self._singularize(app_name),
+        }
+    
+    def _get_feature_variables(self, request: TemplateRequest) -> Dict[str, Any]:
+        """Get feature-specific variables."""
+        features_dict = {}
+        
+        # Create feature flags
+        for feature in AppFeature:
+            features_dict[feature.value] = feature in request.features
+        
+        # Add feature groups
+        features_dict.update({
+            'has_authentication': any(f in request.features for f in [
+                AppFeature.AUTHENTICATION, AppFeature.SECURITY
+            ]),
+            'has_api': any(f in request.features for f in [
+                AppFeature.API, AppFeature.SERIALIZERS, AppFeature.VIEWSETS
+            ]),
+            'has_admin': AppFeature.ADMIN in request.features,
+            'has_forms': AppFeature.FORMS in request.features,
+            'has_tests': AppFeature.TESTS in request.features,
+            'has_models': AppFeature.MODELS in request.features,
+            'has_views': AppFeature.VIEWS in request.features,
+            'has_urls': AppFeature.URLS in request.features,
+            
+            # Advanced features
+            'has_advanced_features': any(f in request.features for f in [
+                AppFeature.SERIALIZERS, AppFeature.VIEWSETS, AppFeature.FILTERS,
+                AppFeature.PAGINATION, AppFeature.SECURITY, AppFeature.TASKS
+            ]),
+            
+            # Django-CFG specific
+            'is_django_cfg': request.app_type == AppType.DJANGO_CFG,
+            'has_cfg_features': any(f in request.features for f in [
+                AppFeature.CFG_CONFIG, AppFeature.CFG_MODULES
+            ]),
+        })
+        
+        return {'features': features_dict}
+    
+    def _get_computed_variables(
+        self,
+        request: TemplateRequest,
+        existing_vars: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Get computed variables based on existing variables."""
+        app_name = existing_vars.get('app_name', 'myapp')
+        
+        computed = {
+            # Model class names
+            'model_class': f"{self._to_pascal_case(app_name)}Model",
+            'admin_class': f"{self._to_pascal_case(app_name)}Admin",
+            'form_class': f"{self._to_pascal_case(app_name)}Form",
+            'serializer_class': f"{self._to_pascal_case(app_name)}Serializer",
+            
+            # View class names
+            'list_view_class': f"{self._to_pascal_case(app_name)}ListView",
+            'detail_view_class': f"{self._to_pascal_case(app_name)}DetailView",
+            'create_view_class': f"{self._to_pascal_case(app_name)}CreateView",
+            'update_view_class': f"{self._to_pascal_case(app_name)}UpdateView",
+            'delete_view_class': f"{self._to_pascal_case(app_name)}DeleteView",
+            
+            # URL patterns
+            'url_namespace': app_name,
+            'url_prefix': self._to_kebab_case(app_name),
+            
+            # Template paths
+            'template_dir': app_name,
+            'list_template': f"{app_name}/list.html",
+            'detail_template': f"{app_name}/detail.html",
+            'form_template': f"{app_name}/form.html",
+            
+            # Database table name
+            'db_table': f"{app_name}_{self._to_snake_case(app_name)}model",
+            
+            # Permissions
+            'add_permission': f"{app_name}.add_{self._to_snake_case(app_name)}model",
+            'change_permission': f"{app_name}.change_{self._to_snake_case(app_name)}model",
+            'delete_permission': f"{app_name}.delete_{self._to_snake_case(app_name)}model",
+            'view_permission': f"{app_name}.view_{self._to_snake_case(app_name)}model",
+        }
+        
+        return computed
+    
+    # String transformation utilities
+    def _to_snake_case(self, text: str) -> str:
+        """Convert text to snake_case."""
+        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
+        s2 = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1)
+        return s2.lower().replace(' ', '_').replace('-', '_')
+    
+    def _to_camel_case(self, text: str) -> str:
+        """Convert text to camelCase."""
+        components = re.split(r'[_\s-]+', text.lower())
+        return components[0] + ''.join(word.capitalize() for word in components[1:])
+    
+    def _to_pascal_case(self, text: str) -> str:
+        """Convert text to PascalCase."""
+        components = re.split(r'[_\s-]+', text.lower())
+        return ''.join(word.capitalize() for word in components)
+    
+    def _to_kebab_case(self, text: str) -> str:
+        """Convert text to kebab-case."""
+        return self._to_snake_case(text).replace('_', '-')
+    
+    def _to_title_case(self, text: str) -> str:
+        """Convert text to Title Case."""
+        return text.replace('_', ' ').replace('-', ' ').title()
+    
+    def _pluralize(self, text: str) -> str:
+        """Simple pluralization."""
+        if text.endswith('y'):
+            return text[:-1] + 'ies'
+        elif text.endswith(('s', 'sh', 'ch', 'x', 'z')):
+            return text + 'es'
+        else:
+            return text + 's'
+    
+    def _singularize(self, text: str) -> str:
+        """Simple singularization."""
+        if text.endswith('ies'):
+            return text[:-3] + 'y'
+        elif text.endswith('es') and not text.endswith(('ses', 'ches', 'xes', 'zes')):
+            return text[:-2]
+        elif text.endswith('s') and not text.endswith('ss'):
+            return text[:-1]
+        else:
+            return text

django_cfg/modules/django_app_agent/services/validation_service/__init__.py

@@ -0,0 +1,25 @@
+"""
+Validation Service for Django App Agent Module.
+
+This package provides comprehensive code validation including
+syntax checking, Django best practices, security analysis,
+and quality metrics calculation.
+"""
+
+from .main import ValidationService
+from .models import ValidationRequest, ValidationResult, ValidationIssue
+from .syntax_validator import SyntaxValidator
+from .django_validator import DjangoValidator
+from .security_validator import SecurityValidator
+from .quality_validator import QualityValidator
+
+__all__ = [
+    "ValidationService",
+    "ValidationRequest",
+    "ValidationResult", 
+    "ValidationIssue",
+    "SyntaxValidator",
+    "DjangoValidator",
+    "SecurityValidator",
+    "QualityValidator",
+]