A comprehensive Django project showcasing 19 specialized apps covering advanced topics like real-time communication, performance optimization, concurrency handling, search engines, asynchronous processing, and enterprise patterns.

• 🔥 Real-time WebSocket applications (Chat, Notifications, Dashboard, Presence)
• 🚀 Performance optimization with Redis caching, Elasticsearch, and query optimization
• ⚡ Asynchronous processing with Celery, Redis, and background tasks
• 🔒 Advanced security with custom middleware, rate limiting, and permission systems
• 📊 Monitoring & Analytics with MongoDB integration and comprehensive logging
• 🐳 Containerized with Docker and production-ready configurations
• 🔍 Semantic search with Elasticsearch and dense vector embeddings
• 📱 Multi-tenant architecture with isolated data and user management
• 🎯 Design patterns implementation (Factory, Observer, Strategy, Proxy, Command)
• 📈 Scalable architecture ready for production deployment

• Microservices-ready with modular app structure
• Event-driven with Kafka integration and fallback mechanisms
• API-first design with comprehensive REST endpoints
• Real-time capabilities using Django Channels and WebSockets
• Multi-database support (PostgreSQL, MongoDB, Redis)
• Search optimization with Elasticsearch and semantic vectors
• Task scheduling with Celery Beat and periodic tasks
• File management with cloud storage providers (AWS S3, Google Cloud)

• Django developers wanting to learn advanced patterns
• Full-stack engineers building real-time applications
• DevOps engineers working with containerized Django apps
• Backend developers implementing enterprise features
• Students learning Django best practices and scalability

Este projeto é um repositório de estudos organizados em 19 apps Django distintos, com foco em soluções reais de performance, concorrência e boas práticas.

• Modela livros com autor, tags e comentários
• Usa select_related, prefetch_related e annotate para otimizar queries
• Permite filtros por título, autor, tags e número de comentários
• Conta e ordena livros por número de comentários (comments_count)
• Utiliza SerializerMethodField apenas quando necessário
• Integração com Cache Redis:
  • Cacheia listagem de livros (/books/) sensível a filtros, ordenação e paginação
  • Cacheia detalhes de livros individuais (/books/{id}/)
  • Geração automática de chaves únicas de cache baseadas nos parâmetros da URL
  • Expiração automática dos caches em 5 minutos
  • Invalidação de cache nas operações de criação e atualização de livros
• Comandos para gerar dados fictícios:

  python manage.py populate_books          # Cria livros com tags e autores
  python manage.py populate_comments       # Gera comentários aleatórios
  python manage.py reindex_semantic_books  # Gera indice busca semantica

• Salas privadas (1-1) ou em grupo (2+ usuários)
• Envio de mensagens via WebSocket e fallback por API REST
• Histórico completo por sala
• Suporte a diferentes tipos de mensagem (text, image, link, etc.)
• Avatar dos usuários no retorno das mensagens e salas
• Integração com Channels (WebSocket) e Celery (opcional para notificações)

• Simula checkout com ajuste de estoque seguro
• Usa select_for_update com transaction.atomic()
• Permite testes de concorrência com Celery ou scripts externos
• Integração com Elasticsearch via django-elasticsearch-dsl somente local
• Indexação automática de produtos ao criar, editar ou remover
• Comando para indexação em massa:

  python manage.py index_products

• Gera relatórios CSV de usuários ativos
• Executa a geração de arquivos via Celery + Redis
• Atualiza status (pending, processing, done, failed)

• Filtros completos: textos, datas, números, booleanos e relacionamentos
• Ordenações dinâmicas: order_by=rating, order_by=purchases, ordering=-price, etc.
• Filtros especiais: avg_rating_min, min_purchases, only_free, is_featured
• Busca full-text otimizada usando Elasticsearch:
• Busca léxica com multi_match (boost em title)
• Autocomplete inteligente (edge_ngram) no título dos cursos
• Facets dinâmicos (agregações) para categorias, tags e faixas de preço
• Integração flexível local com Elasticsearch apenas em ambiente de desenvolvimento(USE_ELASTIC configurado via settings.PROJECT_ENV)
• Fallback automático para consultas Django ORM em ambientes sem Elasticsearch
• Notificações em tempo real para novos cursos publicados, usando WebSocket (Django Channels)

• Baseado no campo access_level do model Profile
• Permissões com IsAdmin, IsSupport, IsUser, etc.
• Controle de acesso por papel via DRF (has_permission)
• Pode ser expandido para RBAC ou ACL no futuro

• WebSocket com autenticação via token /ws/notifications/
• Suporte a notificações globais (obj_code='platform', obj_id=None) e individuais (obj_code='user', obj_id=user.id)
• Broadcast da mensagem para todos os usuários online, mas com uma única instância persistida
• Modelos auxiliares:
  • UserNotificationRead: marca notificações como lidas por usuário
  • UserNotificationDeleted: armazena quais usuários "excluíram" notificações
• Notificações retornadas já indicam se foram lidas (read: true/false) e ocultam as que foram marcadas como excluídas
• Integração com course: ao criar um novo curso, é disparada uma notificação em tempo real
• Método PATCH para marcar como lida:
  PATCH /api/v1/notifications/<id>/mark-as-read/

• Captura automaticamente ações de create, update e delete
• Armazena: usuário, modelo afetado, ID, representação e mudanças
• Uso de signals genéricos e model_to_dict com DjangoJSONEncoder
• Visualização somente leitura no Django Admin
• Ideal para rastreabilidade e conformidade de segurança

• Model Tenant com vínculo a múltiplos usuários
• Middleware que injeta request.tenant automaticamente
• Mixin TenantQuerysetMixin para isolamento por queryset
• Exemplo de uso com model Project, vinculado ao tenant

• Criação de cotas de uso por tipo de ação (ex: upload)
• Validação automática via middleware e/ou throttle do DRF
• Rate Limiting com planos dinâmicos:
  • free: 50 requisições/minuto
  • pro: 200 requisições/minuto
  • admin: 1000 requisições/minuto
• Implementado via CustomUserRateThrottle com base em user.profile.plan
• Middleware consulta e bloqueia se limite for atingido
• Armazena consumo diário em UserQuota (opcional)
• Reset diário automático (se implementado com cron ou Celery)
• Exemplo prático: limitar acesso à API pública ou operações sensíveis
• Comando para testar limites via terminal:

  python manage.py test_throttle --token=SEU_TOKEN_JWT

• WebSocket com autenticação via token /ws/presence/
• Rastreia usuários online
• API: GET /api/v1/online-users/
• Model UserPresence: user, is_online, last_seen

• WebSocket com autenticação via token /ws/dashboard/
• Envia dados agregados: total de users, cursos, livros, relatórios
• Atualiza automaticamente ao criar user, course, book, report ou notification
• Ideal para visualização de métricas sem recarregar a página

• Tecnologias Utilizadas:

  • Celery para tarefas assíncronas
  • Backend SMTP (AWS SES) para envio seguro e confiável
  • Django EmailMessage para construção e envio dos e-mails
  • Banco de Dados para armazenamento dos templates de e-mail

• Funcionalidades:

  • Envio de e-mail para todos os usuários desacoplado via send_email()
  • Integração com templates dinâmicos, permitindo o uso de variáveis no corpo do e-mail
  • Pronto para integração com sistemas de alertas e notificações
  • Cadastro de Books e Courses com notificações automáticas
  • Encadeamento de Tarefas: Chamadas de uma task para outra, como no caso do envio d e-mail para todos os administradores após um evento.

• Upload de imagens vinculado ao usuário autenticado
• Validação automática no upload:
  • Formatos permitidos: JPEG, JPG, PNG, WEBP
  • Tamanho máximo: 5MB
  • Dimensões mínimas: 300x300 px
• Processamento assíncrono com Celery após upload:
  • Geração de 3 tamanhos: thumbnail (150x150), medium (600px), large (1200px)
  • Conversão automática da imagem para JPEG ou WEBP
• Campo output_format para o usuário escolher o formato de saída
• Campos disponíveis:
  • original_image, thumbnail, medium, large, output_format, uploaded_at
• Integração com SQS, não é possível testar localmente.

• Agendamento automático de tarefas recorrentes com django-celery-beat
• Task periódica para resetar cotas diárias do app throttle
• Execução programada via CrontabSchedule
• Integração com Celery Worker e Beat
• Script automatizado no apps.py registra a PeriodicTask no primeiro load
• Totalmente compatível com ambientes de produção no ECS

• Visualização completa do histórico de execuções de tarefas Celery
• Exibe: task_id, task_name, status, tempo de execução (runtime), data de criação e conclusão
• Filtros por status (SUCCESS, FAILURE, PENDING, etc.) e busca por nome ou ID
• Integração com django-celery-results, com backend de resultados armazenados no banco de dados
• Task fallback inteligente: preenche automaticamente o task_name se ausente
• Ideal para ambientes com múltiplas workers e tarefas periódicas programadas

• Implementa busca semântica baseada em Dense Vectors usando cosine similarity
• Integração local com sentence-transformers (all-MiniLM-L6-v2) para geração de embeddings
• Utiliza ElasticSearch 8+ para suporte a dense_vector nativo
• Cria um índice dedicado semantic_books para armazenar vetores de significado
• Busca híbrida combinando:
  • Semântica (similaridade de vetores)
  • Lexical (multi_match textual) com boost no título
• Filtro automático para retornar apenas resultados relevantes (score ≥ 6.0)
• APIs disponíveis:

  GET /api/semantic-search/?q=termo_de_busca

• Implementa envio e consumo de eventos Kafka diretamente do Django
• Configuração dinâmica de broker e tópicos via .env (KAFKA_BROKER_URL, KAFKA_COURSE_TOPIC)
• Producer resiliente com:
  • retry com backoff exponencial (tenacity)
  • circuit breaker com auto-recovery (pybreaker)
  • fallback local: eventos salvos em disco se Kafka estiver offline
• Comando para reenviar eventos salvos em fallback:

  python manage.py resend_kafka_fallback

• Estrutura modular:
  • Producers: envio de eventos por domínio (course, book)
  • Consumers: escutam tópicos de forma desacoplada
  • Utils: cliente Kafka, producer resiliente, fallback
• Integração com o app course via Django Signals
• Fluxo completo com logs e tolerância a falhas
• APIs e comandos disponíveis:

  # Producer interno via Signal
  send_course_created_event(course_instance)
  
  # Envio manual em lote (teste fila Kafka)
  python manage.py kafka_test
  
  # Consumer manual
  from kafka_events.consumers.course_consumer import consume_course_created_events
  consume_course_created_events()

• Modela tópicos com título, descrição, nível (fundamental, intermediate, advanced)
• Admin com coloração dinâmica do campo nível usando format_html
• Suporte a inlines de estudo com o modelo KnowledgeStudy
• Registro de estudos realizados por usuários (com notas e data)
• Ações em lote no admin para marcar tópicos como recomendados
• Comando para popular tópicos avançados com populate_knowledge
• Comando para simular estudos com usuários via populate_knowledge_studies
• Pronto para servir como referência didática ou base para sistema de aprendizado interno

• Proteções ativas com headers HTTP:
• X-Frame-Options: DENY → bloqueia clickjacking ao proibir iframes externos
• X-Content-Type-Options: nosniff → evita que o navegador interprete arquivos como scripts (MIME sniffing)
• Strict-Transport-Security: max-age=63072000; includeSubDomains → força o uso de HTTPS (requer ambiente seguro)
• Content-Security-Policy: default-src 'self' → impede carregamento de scripts e recursos de terceiros não autorizados (protege contra XSS)
• Como testar:
• Acesse qualquer rota autenticada
• Verifique os headers no navegador (DevTools → Network → Headers) ou via curl:

  curl -I http://localhost:8000/

• Armazenamento eficiente de eventos usando MongoDB
• Paginação padrão DRF com suporte a grandes volumes de dados
• API REST para listagem e consulta de eventos
• Integração com o projeto Django utilizando o driver pymongo
• Paginação customizada utilizando o padrão LimitOffsetPagination
• Suporte a ordenação por campos específicos

• Upload de arquivos de forma desacoplada, segura e escalável
• Suporte a múltiplos storages: AWS S3 ou Google Cloud Storage
• Escolha do provedor via variável de ambiente (USE_AWS)
• Geração de nomes de arquivos com hash único via upload_to
• URLs automáticas compatíveis com CDN (CloudFront, GCP CDN)
• Extensível para uso de signed URLs e integração com cache
• Preparado para produção com storages externos desacoplados do backend

• Cliente HTTP robusto com suporte a retries automáticos e exponencial backoff
• Registro completo de chamadas HTTP: método, URL, tempo de resposta, status e payload
• Suporte nativo a headers customizados e payloads JSON
• Centraliza interações com serviços externos (ex: OpenAI, APIs públicas, webhooks)
• Armazena falhas para auditoria e facilita troubleshooting
• Integração fácil com requests + Retry do urllib3

python -m venv .env
source .env/bin/activate

Crie um arquivo venv.sh baseado no venv_example.sh e rode:

chmod +x venv.sh
source venv.sh

pip install -r requirements.txt
python manage.py migrate
python manage.py createsuperuser

daphne api_core.asgi:application

O projeto usa Django Channels com ASGI, necessário para WebSockets.

docker-compose up -d

1. Rode o worker Celery:

celery -A api_core worker --loglevel=info

2. Rode o beat Celery:

celery -A api_core beat --loglevel=info

Este projeto utiliza Elasticsearch para otimizar buscas avançadas no app course, disponível apenas em ambiente de desenvolvimento (USE_ELASTIC configurado via settings.PROJECT_ENV).

• Docker instalado
• Compose disponível (docker-compose)
• Elasticsearch 8.x ou superior

Para utilizar a busca com Elasticsearch localmente, execute o seguinte comando (apenas uma vez):

docker run -d \
  --name elastic \
  -p 9200:9200 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  docker.elastic.co/elasticsearch/elasticsearch:8.12.1

curl http://localhost:9200

settings.py

# Usar Elastic apenas em ambiente local
USE_ELASTIC = PROJECT_ENV == "local"

# Config Elasticsearch
ELASTICSEARCH_DSL = {
    'default': {
        'hosts': 'localhost:9200'
    },
}

python manage.py search_index --delete --models course.Course

python manage.py search_index --create --models course.Course

python manage.py index_courses

Esses comandos garantem que o índice courses esteja atualizado conforme o CourseDocument.

• Busca full-text (multi_match) com boost para title
• Autocomplete inteligente com edge_ngram
• Fallback automático para consultas ORM caso USE_ELASTIC = False

O projeto está integrado com dois geradores de documentação OpenAPI para APIs REST:

• 🔍 Swagger UI e ReDoc com drf-spectacular
• 📄 Swagger UI com drf-yasg

• drf-spectacular

  • /schema/ → OpenAPI JSON
  • /schema/swagger/ → Swagger UI
  • /schema/redoc/ → ReDoc

• drf-yasg

  • /swagger/ → Swagger UI
  • /redoc/ → ReDoc
  • /swagger.json → JSON do schema

Os endpoints estão organizados por aplicação no Swagger e ReDoc através da propriedade tags, permitindo fácil navegação por áreas da plataforma:

• Books → Endpoints de livros (/api/v1/books/)
• Courses → Endpoints de cursos (/api/v1/courses/)
• Chat → Sistema de mensagens privadas (/api/v1/message/)
• Ecommerce → Produtos e pedidos com controle de estoque (/api/v1/ecommerce/)
• Throttle → Limites de uso da API (/api/v1/throttle/)
• Scheduler → Agendamentos periódicos com Celery Beat
• Image Processing → Upload e conversão de imagens
• Monitor → Painel de tarefas assíncronas com Celery
• ...entre outros módulos

A documentação foi incrementada com:

• @extend_schema (drf-spectacular) para descrições, exemplos e parâmetros
• @swagger_auto_schema (drf-yasg) para personalização individual de métodos
• Exemplo de resposta (OpenApiExample)
• Parâmetros de consulta (OpenApiParameter), como ?ordering=-created_at

[
  {
    "id": 94,
    "title": "Métodos Django",
    "score": 8.92
  },
  {
    "id": 95,
    "title": "Django Queries",
    "score": 8.94
  },
  {
    "id": 96,
    "title": "Django OOP",
    "score": 9.05
  }
]

• ElasticSearch 8.11+
• Kibana 8.11+
• Django REST Framework
• django-elasticsearch-dsl
• sentence-transformers (Hugging Face)

python manage.py reindex_semantic_books

• Gera embeddings e reindexa todos os livros semanticamente no Elastic.

• 📡 Chamada a APIs com instabilidade: como GPT-4 ou serviços externos que demandam tolerância a falhas
• 🔁 Retentativas seguras em chamadas que podem retornar 500, 502 ou 429
• 📊 Observabilidade: monitoramento de latência e análise de padrões de erro
• 🔐 Interação com serviços autenticados, como envio de payloads via Authorization Bearer
• 🛠️ Ambiente de testes: integração com endpoints de simulação como httpbin.org para validação de lógica HTTP
• 🔍 Auditoria: armazenar requisições feitas e seus resultados para futura análise, especialmente em operações críticas

Este projeto aplica diversos Design Patterns clássicos da engenharia de software, tanto de forma implícita (como boas práticas do Django) quanto explicitamente por meio da organização modular, tasks assíncronas e arquitetura desacoplada.

• Onde: Serializers (serializer.create())
• Exemplo: UploadedImageSerializer, CourseSerializer
• Descrição: Os serializers funcionam como fábricas para criação de objetos com lógica de validação e instanciamento encapsulada.

• Onde: Celery + Django Signals
• Exemplo: create_thumbnail (task assíncrona), monitor.signals.fill_task_name_if_missing
• Descrição: Eventos disparam ações subsequentes como notificações ou transformações de dados, desacopladas da lógica principal.

• Onde: manage.py custom commands
• Exemplo: python manage.py reset_user_quotas
• Descrição: Lógica encapsulada em comandos reutilizáveis e automatizáveis.

• Onde: Filtros dinâmicos, Permissões, WebSocket Consumers
• Exemplo: CourseFilter, IsOwnerPermission, ChatConsumer
• Descrição: Algoritmos intercambiáveis selecionados em tempo de execução com base no contexto.

• Onde: Serializers com campos computados e propriedades em models
• Exemplo: UserMiniSerializer, Room.last_message (no chat)
• Descrição: Encapsula acesso a objetos complexos com interface simplificada.

Este projeto implementa o Decorator Pattern para encapsular comportamentos reutilizáveis em torno de views, tasks, actions administrativas e consumers WebSocket.

@shared_task(name='image_processing.create_thumbnail')
@log_task_execution
def create_thumbnail(image_id):
  pass

Simular compras simultâneas com ajuste seguro de estoque.

1. Gere um produto com stock=1
2. Use script com threads e dois tokens diferentes:

import threading, requests

def comprar(token):
    r = requests.post("http://localhost:8000/api/v1/orders/", headers={"Authorization": f"Bearer {token}"}, json={"product_id": 1, "quantity": 1})
    print(r.status_code, r.json())

threading.Thread(target=comprar, args=(token1,)).start()
threading.Thread(target=comprar, args=(token2,)).start()

• O primeiro pedido finaliza
• O segundo falha com "Estoque insuficiente"

Gerar relatórios de usuários ativos em background

• POST /api/v1/reports/ com payload vazio
• Task Celery é disparada: generate_user_report
• Gera CSV em media/reports/ e atualiza o campo file_path

{
  "status": "done",
  "file_path": "/media/reports/users_report_1.csv"
}

Book.objects.all()  # causa N+1

Book.objects.select_related("author").prefetch_related("tags", "comments").annotate(
    comments_count=Count("comments")
)

{
  "id": 1,
  "title": "Harry Potter",
  "author": {
    "id": 2,
    "username": "autor"
  },
  "tags": [
    {"id": 1, "name": "Fantasia"},
    {"id": 2, "name": "Magia"}
  ],
  "comments_count": 12
}

Evite SerializerMethodField com queries internas. Use dados pré-carregados ou annotate().

from apps.throttle.utils import check_and_increment_quota


class UploadViewSet(ModelViewSet):
    serializer_class = ReportRequestSerializer
    permission_classes = [IsAuthenticated]
    http_method_names = ['post']

    def create(self, request, *args, **kwargs):
        # função => check_and_increment_quota(request.user, "upload") 
        check_and_increment_quota(request.user, "upload")
        return Response({"message": "Upload feito com sucesso!"}, status=status.HTTP_201_CREATED)

Listagem de cursos com suporte completo a filtros dinâmicos, relacionamentos e ordenação por popularidade ou avaliação.

• title=django (busca no título)
• description=avançado (busca na descrição)
• price_min=100&price_max=300
• start_date_from=2025-04-01&start_date_to=2025-04-30
• workload_min=10&workload_max=40
• tags=1,3 ou tag=python
• is_active=true, is_free=false, is_featured=true
• category=2, instructor=1
• avg_rating_min=4 (média mínima de avaliação)
• min_purchases=10 (mínimo de compras pagas)
• only_free=true (gratuitos apenas)

Use o parâmetro order_by ou ordering:

• order_by=rating → cursos com melhor avaliação média
• order_by=purchases → cursos mais comprados
• ordering=-created_at → mais recentes
• ordering=-price → mais caros primeiro

GET /api/v1/courses/?price_min=50&tags=1,3&is_free=false&order_by=rating

Ao criar um curso via POST /api/v1/courses/, todos os usuários conectados via /ws/notifications/ recebem notificações em tempo real com o título do curso!

Utilize o wscat para testar no terminal:

wscat -c "ws://localhost:8000/ws/notifications/?token=TOKEN_DO_USUARIO"

POST /api/v1/uploads-images/
Authorization: Token SEU_TOKEN

FormData:
- original_image: arquivo (.jpg, .png, .webp, etc.)
- output_format: JPEG ou WEBP (opcional, padrão: JPEG)

Uma lista usuários online no GET /api/v1/online-users/, todos os usuários conectados via /ws/presence/ entram numa lista de users online!

Utilize o wscat para conectar um usário:

wscat -c "ws://localhost:8000/ws/presence/?token=TOKEN_DO_USUARIO"

Envie mensagens entre usuários autenticados em tempo real via WebSocket, com fallback por API REST.

O chat privado é baseado em salas (Room) que conectam N usuários.

Crie (ou recupere) uma sala com outro usuário via:

POST /api/v1/rooms/
Authorization: Token TOKEN_DO_USUARIO
{
  "user_ids": [4, 5],
  "name": "Grupo de Estudos"
}

wscat -c "ws://localhost:8000/ws/chat/room/ROOM_ID/?token=TOKEN_DO_USUARIO"

Envie uma mensagem assim via websocket:

{
  "type_message": "text",
  "content": {
    "text": "Olá, tudo bem?"
  }
}

Enviar mensagens via API REST (opcional):

POST /api/v1/message/send/
Authorization: Token TOKEN_DO_USUARIO
{
  "room_id": 12,
  "type_message": "image",
  "content": {
    "url": "https://meu-bucket.s3.amazonaws.com/foto.jpg",
    "caption": "Foto da reunião"
  }
}

Este app fornece dados agregados de forma dinâmica para um painel administrativo, usando WebSocket para envio de informações em tempo real.

O WebSocket do painel administrativo pode ser acessado com:

wscat -c "ws://localhost:8000/ws/dashboard/?token=TOKEN_DO_USUARIO"

{
  "type": "dashboard_data",
  "users_count": 51,
  "courses_count": 40,
  "reports_count": 21,
  "books_count": 85
}

python manage.py populate_users               # Cria 100 usuarios com faker
python manage.py populate_books               # Cria 100 livros aleatórios
python manage.py populate_comments            # Cria comentários aleatórios nos livros
python manage.py populate_courses             # Cria 30 cursos aleatórios
python manage.py populate_rating              # Cria avaliações para cursos
python manage.py populate_payment             # Cria pagamentos de cursos
python manage.py populate_tenants             # Cria tenants com usuários
python manage.py populate_projects            # Cria projetos associados aos tenants
python manage.py populate_rooms_and_messages  # Cria rooms e messages aleatórias
python manage.py reindex_semantic_books       # Cria indice de busca semantica
python manage.py index_courses                # Cria indice de cursos ElasticSearch
python manage.py index_products               # Cria indice de produtos ElasticSearch
python manage.py populate_knowledge           # Cria lista de knowledge
python manage.py populate_knowledge_studies   # Cria alunos para knowledge (inlines)
python manage.py populate_analytics           # Cria 1000 dados no mongodb

Desenvolvido para estudos aprofundados em Django com casos reais e foco em performance, concorrência, boas práticas e comunicação em tempo real.

Roberto Lima

• 📧 Email: [email protected]
• 🔗 GitHub Roberto Lima
• 💼 Linkedin Roberto Lima
• 🌐 Website Roberto Lima
• 👤 Gravatar Roberto Lima