django-cfg 1.1.81__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/apps/knowbase/views/chat_views.py

@@ -0,0 +1,181 @@
+"""
+Chat API views for RAG-powered conversations.
+"""
+
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from django_ratelimit.decorators import ratelimit
+from django.utils.decorators import method_decorator
+from drf_spectacular.utils import extend_schema, OpenApiExample
+
+from ..models import ChatSession
+from ..services import ChatService
+from ..serializers import (
+    ChatSessionCreateSerializer,
+    ChatSessionSerializer,
+    ChatQuerySerializer,
+    ChatResponseSerializer,
+    ChatHistorySerializer
+)
+from .base import BaseKnowledgeViewSet
+
+
+class ChatSessionViewSet(BaseKnowledgeViewSet):
+    """Chat session management endpoints."""
+    
+    queryset = ChatSession.objects.all()
+    serializer_class = ChatSessionSerializer
+    service_class = ChatService
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'create':
+            return ChatSessionCreateSerializer
+        return ChatSessionSerializer
+    
+    @extend_schema(
+        summary="Create new chat session",
+        responses={201: ChatSessionSerializer}
+    )
+    def create(self, request, *args, **kwargs):
+        """Create new chat session."""
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        
+        service = self.get_service()
+        session = service.create_session(
+            title=serializer.validated_data['title'],
+            model_name=serializer.validated_data['model_name'],
+            temperature=serializer.validated_data['temperature'],
+            max_context_chunks=serializer.validated_data['max_context_chunks']
+        )
+        
+        response_serializer = ChatSessionSerializer(session)
+        return Response(response_serializer.data, status=status.HTTP_201_CREATED)
+    
+    @extend_schema(
+        summary="List user chat sessions",
+        responses={200: ChatSessionSerializer(many=True)}
+    )
+    def list(self, request, *args, **kwargs):
+        """List user chat sessions with filtering."""
+        # Add filtering by is_active
+        queryset = self.get_queryset()
+        
+        # Filter by active status if requested
+        is_active = request.query_params.get('is_active')
+        if is_active is not None:
+            is_active_bool = is_active.lower() in ('true', '1', 'yes')
+            queryset = queryset.filter(is_active=is_active_bool)
+        
+        # Apply pagination
+        page = self.paginate_queryset(queryset)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)
+    
+    @extend_schema(
+        summary="Archive chat session",
+        responses={200: ChatSessionSerializer}
+    )
+    @action(detail=True, methods=['post'])
+    def archive(self, request, pk=None):
+        """Archive (deactivate) chat session."""
+        session = self.get_object()
+        session.archive()
+        
+        serializer = self.get_serializer(session)
+        return Response(serializer.data)
+    
+    @extend_schema(
+        summary="Activate chat session",
+        responses={200: ChatSessionSerializer}
+    )
+    @action(detail=True, methods=['post'])
+    def activate(self, request, pk=None):
+        """Activate chat session."""
+        session = self.get_object()
+        session.activate()
+        
+        serializer = self.get_serializer(session)
+        return Response(serializer.data)
+
+
+class ChatViewSet(BaseKnowledgeViewSet):
+    """Chat query endpoints."""
+    
+    service_class = ChatService
+    serializer_class = ChatResponseSerializer
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'query':
+            return ChatQuerySerializer
+        elif self.action == 'history':
+            return ChatHistorySerializer
+        return ChatResponseSerializer
+    
+    @extend_schema(
+        summary="Process chat query with RAG",
+        request=ChatQuerySerializer,
+        responses={200: ChatResponseSerializer},
+        examples=[
+            OpenApiExample(
+                "Simple Query",
+                value={
+                    "query": "What is machine learning?",
+                    "max_tokens": 1000,
+                    "include_sources": True
+                }
+            )
+        ]
+    )
+    @method_decorator(ratelimit(key='user', rate='30/m', method='POST'))
+    @action(detail=False, methods=['post'])
+    def query(self, request):
+        """Process chat query with RAG context."""
+        serializer = ChatQuerySerializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        
+        service = self.get_service()
+        
+        # Create session if not provided
+        session_id = serializer.validated_data.get('session_id')
+        if not session_id:
+            session = service.create_session()
+            session_id = str(session.id)
+        else:
+            session_id = str(session_id)
+        
+        # Process query
+        result = service.process_query(
+            session_id=session_id,
+            query=serializer.validated_data['query'],
+            max_tokens=serializer.validated_data['max_tokens'],
+            include_sources=serializer.validated_data['include_sources']
+        )
+        
+        return Response(result)
+    
+    @extend_schema(
+        summary="Get chat history",
+        responses={200: ChatHistorySerializer}
+    )
+    @action(detail=True, methods=['get'])
+    def history(self, request, pk=None):
+        """Get chat session history."""
+        service = self.get_service()
+        messages = service.get_session_history(session_id=pk)
+        
+        data = {
+            'session_id': pk,
+            'messages': messages,
+            'total_messages': len(messages)
+        }
+        
+        serializer = ChatHistorySerializer(data)
+        return Response(serializer.data)

django_cfg/apps/knowbase/views/document_views.py

@@ -0,0 +1,183 @@
+"""
+Document management API views.
+"""
+
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated, IsAdminUser
+from django_ratelimit.decorators import ratelimit
+from django.utils.decorators import method_decorator
+from django.db import models
+from drf_spectacular.utils import extend_schema, OpenApiExample, OpenApiParameter
+
+from ..models import Document
+from ..services import DocumentService
+from ..serializers import (
+    DocumentCreateSerializer,
+    DocumentSerializer,
+    DocumentStatsSerializer,
+    DocumentProcessingStatusSerializer
+)
+from .base import BaseKnowledgeViewSet
+
+
+class DocumentViewSet(BaseKnowledgeViewSet):
+    """Document management endpoints - Admin only."""
+    
+    queryset = Document.objects.all()
+    serializer_class = DocumentSerializer
+    service_class = DocumentService
+    permission_classes = [IsAuthenticated, IsAdminUser]
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'create':
+            return DocumentCreateSerializer
+        elif self.action == 'stats':
+            return DocumentStatsSerializer
+        elif self.action == 'status':
+            return DocumentProcessingStatusSerializer
+        return DocumentSerializer
+    
+    @extend_schema(
+        summary="Upload new document",
+        description="Upload and process a new knowledge document",
+        responses={
+            201: DocumentSerializer,
+            400: "Validation errors",
+            413: "File too large",
+            429: "Rate limit exceeded"
+        },
+        examples=[
+            OpenApiExample(
+                "Text Document",
+                value={
+                    "title": "API Documentation",
+                    "content": "# API Guide\n\nThis guide explains...",
+                    "file_type": "text/markdown"
+                }
+            )
+        ]
+    )
+    @method_decorator(ratelimit(key='user', rate='10/m', method='POST'))
+    def create(self, request, *args, **kwargs):
+        """Create new document with async processing."""
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        
+        # Use service layer for business logic
+        service = self.get_service()
+        document = service.create_document(
+            title=serializer.validated_data['title'],
+            content=serializer.validated_data['content'],
+            file_type=serializer.validated_data['file_type'],
+            metadata=serializer.validated_data['metadata']
+        )
+        
+        response_serializer = DocumentSerializer(document)
+        return Response(response_serializer.data, status=status.HTTP_201_CREATED)
+    
+    @extend_schema(
+        summary="List user documents",
+        parameters=[
+            OpenApiParameter(
+                name='status',
+                type=str,
+                location=OpenApiParameter.QUERY,
+                description='Filter by processing status'
+            ),
+        ],
+        responses={200: DocumentSerializer(many=True)}
+    )
+    def list(self, request, *args, **kwargs):
+        """List user documents with filtering and pagination."""
+        status_filter = request.query_params.get('status')
+        
+        service = self.get_service()
+        queryset = service.get_user_documents(status=status_filter)
+        
+        # Use DRF pagination
+        page = self.paginate_queryset(queryset)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)
+    
+    @extend_schema(
+        summary="Get document details",
+        responses={
+            200: DocumentSerializer,
+            404: "Document not found"
+        }
+    )
+    def retrieve(self, request, *args, **kwargs):
+        """Get document by ID."""
+        return super().retrieve(request, *args, **kwargs)
+    
+    @extend_schema(
+        summary="Delete document",
+        responses={
+            204: "Document deleted successfully",
+            404: "Document not found"
+        }
+    )
+    def destroy(self, request, *args, **kwargs):
+        """Delete document and all associated chunks."""
+        return super().destroy(request, *args, **kwargs)
+    
+    @extend_schema(
+        summary="Get document processing status",
+        responses={200: DocumentProcessingStatusSerializer}
+    )
+    @action(detail=True, methods=['get'])
+    def status(self, request, pk=None):
+        """Get document processing status."""
+        document = self.get_object()
+        
+        data = {
+            'id': document.id,
+            'status': document.processing_status,
+            'progress': {
+                'chunks_processed': document.chunks_count,
+                'total_tokens': document.total_tokens,
+                'processing_time': document.processing_duration
+            },
+            'error': document.processing_error if document.processing_error else None,
+            'processing_time_seconds': document.processing_duration
+        }
+        
+        serializer = self.get_serializer(data)
+        return Response(serializer.data)
+    
+    @extend_schema(
+        summary="Reprocess document",
+        description="Trigger reprocessing of document chunks and embeddings"
+    )
+    @action(detail=True, methods=['post'])
+    def reprocess(self, request, pk=None):
+        """Trigger document reprocessing."""
+        document = self.get_object()
+        
+        service = self.get_service()
+        service.reprocess_document(str(document.id))
+        
+        return Response({
+            'message': 'Document reprocessing started',
+            'document_id': str(document.id)
+        })
+    
+    @extend_schema(
+        summary="Get processing statistics",
+        responses={200: DocumentStatsSerializer}
+    )
+    @action(detail=False, methods=['get'])
+    def stats(self, request):
+        """Get user's document processing statistics."""
+        service = self.get_service()
+        stats = service.get_processing_stats()
+        
+        serializer = self.get_serializer(stats)
+        return Response(serializer.data)

django_cfg/apps/knowbase/views/public_views.py

@@ -0,0 +1,129 @@
+"""
+Public API views for client access without authentication.
+"""
+
+from rest_framework import viewsets
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from django.db import models
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+
+from ..models import Document, DocumentCategory
+from ..serializers.public_serializers import (
+    PublicDocumentSerializer, 
+    PublicDocumentListSerializer,
+    PublicCategorySerializer
+)
+
+
+class PublicDocumentViewSet(viewsets.ReadOnlyModelViewSet):
+    """Public document endpoints - read-only access for clients."""
+    
+    serializer_class = PublicDocumentSerializer
+    permission_classes = [AllowAny]
+    lookup_field = 'pk'
+    
+    def get_queryset(self):
+        """Get only publicly accessible documents."""
+        return Document.objects.filter(
+            processing_status='completed',
+            is_public=True
+        ).filter(
+            models.Q(categories__isnull=True) | models.Q(categories__is_public=True)
+        ).prefetch_related('categories')
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'list':
+            return PublicDocumentListSerializer
+        return PublicDocumentSerializer
+    
+    @extend_schema(
+        summary="List public documents",
+        description="Get list of all completed and publicly accessible documents",
+        parameters=[
+            OpenApiParameter(
+                name='search',
+                type=str,
+                location=OpenApiParameter.QUERY,
+                description='Search in title and content'
+            ),
+            OpenApiParameter(
+                name='category',
+                type=str,
+                location=OpenApiParameter.QUERY,
+                description='Filter by category name'
+            ),
+        ],
+        responses={200: PublicDocumentListSerializer(many=True)}
+    )
+    def list(self, request, *args, **kwargs):
+        """List all publicly accessible documents with optional filtering."""
+        queryset = self.get_queryset()
+        
+        # Search functionality
+        search = request.query_params.get('search')
+        if search:
+            queryset = queryset.filter(
+                models.Q(title__icontains=search) | 
+                models.Q(content__icontains=search)
+            )
+        
+        # Category filter
+        category = request.query_params.get('category')
+        if category:
+            queryset = queryset.filter(categories__name__iexact=category)
+        
+        # Order by creation date (newest first)
+        queryset = queryset.order_by('-created_at')
+        
+        # Use DRF pagination
+        page = self.paginate_queryset(queryset)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+        
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)
+    
+    @extend_schema(
+        summary="Get public document details",
+        description="Get document details by ID (public access)",
+        responses={
+            200: PublicDocumentSerializer,
+            404: "Document not found"
+        }
+    )
+    def retrieve(self, request, *args, **kwargs):
+        """Get document by ID - public access."""
+        return super().retrieve(request, *args, **kwargs)
+
+
+class PublicCategoryViewSet(viewsets.ReadOnlyModelViewSet):
+    """Public category endpoints - read-only access for clients."""
+    
+    queryset = DocumentCategory.objects.filter(is_public=True)
+    serializer_class = PublicCategorySerializer
+    permission_classes = [AllowAny]
+    lookup_field = 'pk'
+    
+    @extend_schema(
+        summary="List public categories",
+        description="Get list of all public categories",
+        responses={200: PublicCategorySerializer(many=True)}
+    )
+    def list(self, request, *args, **kwargs):
+        """List all public categories."""
+        return super().list(request, *args, **kwargs)
+    
+    @extend_schema(
+        summary="Get public category details",
+        description="Get category details by ID (public access)",
+        responses={
+            200: PublicCategorySerializer,
+            404: "Category not found"
+        }
+    )
+    def retrieve(self, request, *args, **kwargs):
+        """Get category by ID - public access."""
+        return super().retrieve(request, *args, **kwargs)

django_cfg/apps/leads/admin.py

@@ -0,0 +1,70 @@
+from django.contrib import admin, messages
+from django.urls import reverse
+from django.utils.html import format_html
+from django.http import HttpResponseRedirect
+from unfold.admin import ModelAdmin
+from unfold.decorators import action
+from .models import Lead
+
+
+@admin.register(Lead)
+class LeadAdmin(ModelAdmin):
+    list_display = [
+        'name', 'email', 'company', 'contact_type', 'contact_value',
+        'subject', 'status_display', 'created_at'
+    ]
+    list_display_links = ['name', 'email']
+    list_filter = [
+        'status', 'contact_type', 'company', 'created_at'
+    ]
+    search_fields = [
+        'name', 'email', 'company', 'company_site', 
+        'message', 'subject', 'admin_notes'
+    ]
+    readonly_fields = [
+        'created_at', 'updated_at', 'ip_address', 'user_agent'
+    ]
+    
+    fieldsets = (
+        ('Basic Information', {
+            'fields': ('name', 'email', 'company', 'company_site')
+        }),
+        ('Contact Information', {
+            'fields': ('contact_type', 'contact_value')
+        }),
+        ('Message', {
+            'fields': ('subject', 'message', 'extra')
+        }),
+        ('Metadata', {
+            'fields': ('site_url', 'ip_address', 'user_agent'),
+            'classes': ('collapse',)
+        }),
+        ('Status and Processing', {
+            'fields': ('status', 'user', 'admin_notes')
+        }),
+        ('Timestamps', {
+            'fields': ('created_at', 'updated_at'),
+            'classes': ('collapse',)
+        }),
+    )
+    
+    def status_display(self, obj):
+        status_colors = {
+            'new': '#17a2b8',
+            'contacted': '#ffc107',
+            'qualified': '#28a745',
+            'converted': '#007bff',
+            'rejected': '#dc3545'
+        }
+        color = status_colors.get(obj.status, '#6c757d')
+        return format_html(
+            '<span style="background: {}; color: white; padding: 2px 6px; border-radius: 3px; font-size: 11px;">{}</span>',
+            color, obj.get_status_display()
+        )
+    status_display.short_description = 'Status'
+    
+    list_per_page = 50
+    date_hierarchy = 'created_at'
+    
+    def get_queryset(self, request):
+        return super().get_queryset(request).select_related('user')