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

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

@@ -1,211 +0,0 @@
-"""
-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

@@ -1,200 +0,0 @@
-"""
-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

@@ -1,25 +0,0 @@
-"""
-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",
-]