wagtail-enap-designsystem 1.2.1.138__py3-none-any.whl → 1.2.1.140__py3-none-any.whl

enap_designsystem/blocks/form.py

@@ -1,4 +1,7 @@
 from django.db import models
+from django import forms
+from wagtail.admin.forms import WagtailAdminPageForm
+from .security import validate_safe_characters, validate_email_field
 from django.http import JsonResponse
 from django.shortcuts import render, redirect
 from django.core.mail import send_mail
@@ -26,7 +29,7 @@ from wagtail.blocks import StreamBlock, StructBlock, CharBlock
 from ..utils.services import SimpleEmailService
 logger = logging.getLogger(__name__) 
 
-# models.py
+
 from django.db import models
 from wagtail.models import Page
 from wagtail.fields import RichTextField, StreamField
@@ -34,6 +37,37 @@ from wagtail.admin.panels import FieldPanel, MultiFieldPanel, InlinePanel
 from wagtail import blocks
 from wagtail.images.blocks import ImageChooserBlock
 from wagtail.blocks import StreamBlock, StructBlock, CharBlock, RichTextBlock, URLBlock
+
+
+
+
+class SafeFormMixin:
+    """
+    Aplica validação de caracteres em todos os campos
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.apply_character_validation()
+    
+    def apply_character_validation(self):
+        """
+        Aplica validação baseada no tipo de campo
+        """
+        for field_name, field in self.fields.items():
+            if isinstance(field, forms.EmailField):
+                # Para emails, permitir @ e .
+                field.validators.append(validate_email_field)
+            elif isinstance(field, (forms.CharField, forms.TextField)):
+                # Para texto comum, validação padrão
+                field.validators.append(validate_safe_characters)
+
+class FormularioPageForm(SafeFormMixin, WagtailAdminPageForm):
+    pass
+
+
+
+
+
 class TextFieldBlock(blocks.StructBlock):
     """Campo de texto simples"""
     label = blocks.CharBlock(label="Rótulo", max_length=255)
@@ -1913,7 +1947,6 @@ class FormularioPage(Page):
             
             return extracted_fields
         
-        print(f"=== PROCESSANDO {len(self.form_steps)} STEPS (Versão Corrigida) ===")
         
         # Processar cada step
         for index, step_block in enumerate(self.form_steps):
@@ -1937,7 +1970,6 @@ class FormularioPage(Page):
                 'sections': []
             }
             
-            print(f"✅ Step {index + 1}: {len(step_fields)} campos (sem aninhamento)")
             
             # Organizar em seções
             current_section = None
@@ -1962,7 +1994,6 @@ class FormularioPage(Page):
             steps.append(step_data)
         
         total_fields = sum(len(step['fields']) for step in steps)
-        print(f"🎉 RESULTADO: {len(steps)} steps com {total_fields} campos principais")
         
         return steps
 
@@ -2069,6 +2100,59 @@ class FormularioPage(Page):
             context['admin_notified'] = request.GET.get('admin_notified') == '1'
         
         return context
+    
+
+    def validate_form_data(self, form_data, request):
+        """Valida os dados do formulário - VERSÃO COM PROTEÇÃO DE SEGURANÇA"""
+        errors = {}
+        
+        for step in self.get_all_steps():
+            for block in step['fields']:
+                if block.block_type in ['info_text', 'divider', 'section_header']:
+                    continue
+                    
+                field_id = f"{block.block_type}_{block.id}"
+                value = form_data.get(field_id, '')
+                
+                # Verificar se campo condicional deve ser validado
+                if block.block_type in ['city_field', 'conditional_dropdown_field']:
+                    if not self.should_process_conditional_field(block, form_data, request):
+                        continue
+                
+                # NOVA VALIDAÇÃO DE SEGURANÇA - APLICAR A TODOS OS CAMPOS DE TEXTO
+                if isinstance(value, str) and value.strip():
+                    try:
+                        if block.block_type == 'email_field':
+                            # Para emails, usar validador específico
+                            validate_email_field(value)
+                        else:
+                            # Para outros campos de texto, usar validador geral
+                            validate_safe_characters(value)
+                    except ValidationError as e:
+                        errors[field_id] = str(e.message)
+                        continue
+                
+                # Verificar campos obrigatórios
+                if block.value.get('required', False):
+                    if not value or (isinstance(value, list) and not any(value)):
+                        errors[field_id] = 'Este campo é obrigatório'
+                        continue
+                
+                # Validações específicas existentes
+                if block.block_type == 'email_field' and value:
+                    if not self.validate_email(value):
+                        errors[field_id] = 'Email inválido'
+                
+                elif block.block_type == 'cpf_field' and value:
+                    if not self.validate_cpf_9_digits(value):
+                        errors[field_id] = 'CPF deve ter exatamente 11 dígitos'
+                
+                elif block.block_type == 'phone_field' and value:
+                    if not self.validate_phone(value):
+                        errors[field_id] = 'Telefone inválido'
+        
+        return errors
+
     class Meta:
         verbose_name = "Formulário Dinâmico"
         verbose_name_plural = "Formulários Dinâmicos"

enap_designsystem/blocks/html_blocks.py

@@ -7622,6 +7622,13 @@ class SecaoApresentacaoCardsBlock(blocks.StructBlock):
     )
     
     # Título
+    cor_fundo = blocks.ChoiceBlock(
+        choices=BACKGROUND_COLOR_CHOICES,
+        required=False,
+        default='#6A1B9A',  # Roxo como na imagem
+        help_text="Cor de fundo do componente"
+    )
+    
     titulo = blocks.CharBlock(
         required=True,
         max_length=200,

enap_designsystem/blocks/security.py

@@ -0,0 +1,62 @@
+import re
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+def validate_safe_characters(value):
+    """
+    Permite apenas letras, números, espaços e acentos
+    Bloqueia caracteres especiais perigosos E comandos SQL
+    """
+    if not isinstance(value, str) or not value:
+        return
+    
+    # 1. Verificar caracteres permitidos primeiro
+    allowed_pattern = r'^[a-zA-Z0-9À-ÿ\s\.\-@]+$'
+    
+    if not re.match(allowed_pattern, value):
+        raise ValidationError(
+            _('Este campo só aceita letras, números, espaços e acentos.'),
+            code='invalid_characters'
+        )
+    
+    # 2. Verificar comandos SQL proibidos
+    sql_commands = ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'DROP', 'CREATE']
+    
+    # Converter para maiúsculo para comparação
+    value_upper = value.upper()
+    
+    for command in sql_commands:
+        # Verificar se o comando aparece como palavra completa
+        if re.search(r'\b' + command + r'\b', value_upper):
+            raise ValidationError(
+                _('Este campo contém comandos não permitidos.'),
+                code='sql_command_detected'
+            )
+
+
+def validate_email_field(value):
+    """
+    Para campos de email - permite @ e . mas também bloqueia comandos SQL
+    """
+    if not isinstance(value, str) or not value:
+        return
+    
+    # 1. Verificar caracteres permitidos para email
+    allowed_pattern = r'^[a-zA-Z0-9@\.\-_]+$'
+    
+    if not re.match(allowed_pattern, value):
+        raise ValidationError(
+            _('Email contém caracteres não permitidos.'),
+            code='invalid_email_characters'
+        )
+    
+    # 2. Verificar comandos SQL também em emails
+    sql_commands = ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'DROP', 'CREATE']
+    value_upper = value.upper()
+    
+    for command in sql_commands:
+        if re.search(r'\b' + command + r'\b', value_upper):
+            raise ValidationError(
+                _('Email contém comandos não permitidos.'),
+                code='sql_command_in_email'
+            )

enap_designsystem/middleware/filtro_inputs.py

@@ -0,0 +1,116 @@
+# enap_designsystem/blocks/middleware.py
+
+from django.http import HttpResponseBadRequest
+from django.core.exceptions import ValidationError
+from ..blocks.security import validate_safe_characters, validate_email_field
+import logging
+
+logger = logging.getLogger(__name__)
+
+class CharacterFilterMiddleware:
+    """
+    Middleware que filtra caracteres perigosos - COM EXCEÇÕES PARA ADMIN
+    """
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        # Verificar apenas requisições POST
+        if request.method == 'POST':
+            
+            # EXCEÇÕES: Não validar estes campos/URLs
+            if self.should_skip_validation(request):
+                return self.get_response(request)
+            
+            # Verificar cada campo enviado
+            for key, value in request.POST.items():
+                if isinstance(value, str) and value.strip():
+                    
+                    # Pular campos administrativos/técnicos
+                    if self.is_admin_field(key):
+                        continue
+                    
+                    try:
+                        # Para campos de email, usar validação específica
+                        if 'email' in key.lower():
+                            validate_email_field(value)
+                        else:
+                            # Para outros campos, validação geral
+                            validate_safe_characters(value)
+                            
+                    except ValidationError as e:
+                        # Log da tentativa suspeita
+                        logger.warning(f"Caracteres suspeitos bloqueados no campo '{key}': {value[:50]}")
+                        
+                        # Retornar erro
+                        return HttpResponseBadRequest(
+                            f"Campo '{key}' contém caracteres não permitidos por motivos de segurança."
+                        )
+        
+        # Continuar processamento normal
+        return self.get_response(request)
+    
+    def should_skip_validation(self, request):
+        """
+        Determina se deve pular validação para esta requisição
+        """
+        # URLs que devem ser ignoradas
+        skip_urls = [
+            '/admin/',          # Painel admin Django
+            '/cms/',            # Painel admin Wagtail (se usar esta URL)
+            '/django-admin/',   # Admin alternativo
+        ]
+        
+        # Verificar se a URL atual deve ser ignorada
+        for skip_url in skip_urls:
+            if request.path.startswith(skip_url):
+                return True
+        
+        return False
+    
+    def is_admin_field(self, field_name):
+        """
+        Identifica campos administrativos que devem ser ignorados
+        """
+        # Prefixos de campos administrativos
+        admin_prefixes = [
+            'form_steps-',      # StreamField do formulário
+            'csrfmiddlewaretoken',  # Token CSRF
+            'action-',          # Ações do admin
+            'select_',          # Seletores do admin
+            '_selected_',       # Campos selecionados
+            'logo_section-',    # Campos de logo
+            'background_image_fundo-',  # Campos de imagem
+            'thank_you_image_section-',  # Campos de agradecimento
+        ]
+        
+        # Sufixos de campos administrativos
+        admin_suffixes = [
+            '-type',            # Tipo do bloco
+            '-deleted',         # Campo deletado
+            '-order',           # Ordem do campo
+            '-id',              # ID do bloco
+        ]
+        
+        # Verificar prefixos
+        for prefix in admin_prefixes:
+            if field_name.startswith(prefix):
+                return True
+        
+        # Verificar sufixos
+        for suffix in admin_suffixes:
+            if field_name.endswith(suffix):
+                return True
+        
+        # Campos específicos do Wagtail
+        wagtail_fields = [
+            'title',            # Título da página
+            'slug',             # Slug da página
+            'seo_title',        # SEO
+            'search_description',  # Descrição
+        ]
+        
+        if field_name in wagtail_fields:
+            return True
+        
+        return False