wagtail-enap-designsystem 1.2.1.144__py3-none-any.whl → 1.2.1.146__py3-none-any.whl

enap_designsystem/models.py

@@ -5028,231 +5028,882 @@ class SistemaVotacaoPage(Page):
 
 
 
-from wagtail.models import Page
-from wagtail.fields import RichTextField, StreamField
-from wagtail.admin.panels import FieldPanel
 
-from .blocks import LAYOUT_STREAMBLOCKS
+
+
+
+
+import logging
+import traceback
+from wagtail.blocks import StreamBlock, StructBlock, ListBlock
+
+logger = logging.getLogger(__name__)
 
 class ShowcaseComponentesDireto(Page):
     """
-    Showcase que renderiza componentes diretamente no template
-    usando valores padrão dos componentes
+    Showcase que renderiza componentes COMPLETOS visualmente
     """
     
     description = RichTextField(
         verbose_name="Descrição",
         help_text="Descrição da biblioteca de componentes",
         blank=True,
-        default="Showcase com renderização direta dos componentes usando valores padrão"
+        default="Showcase visual dos componentes completos"
+    )
+    
+    debug_mode = models.BooleanField(
+        default=False,  # False por padrão para foco na estética
+        verbose_name="Modo Debug",
+        help_text="Ativar para ver informações técnicas"
+    )
+    
+    show_errors_only = models.BooleanField(
+        default=False,
+        verbose_name="Mostrar Apenas Erros",
+        help_text="Mostrar apenas componentes que falharam na renderização"
+    )
+    
+    filter_category = models.CharField(
+        max_length=100,
+        blank=True,
+        verbose_name="Filtrar Categoria",
+        help_text="banners, galerias, carousels, dashboards, formularios, cursos, eventos, navegacao, botoes, conteudo, secoes, cards, interativos, midia, especialidades"
     )
     
     content_panels = Page.content_panels + [
         FieldPanel('description'),
+        FieldPanel('filter_category'),
+        FieldPanel('show_errors_only'),
+        FieldPanel('debug_mode'),
     ]
     
     template = 'enap_designsystem/pages/showcase_components.html'
     
     class Meta:
-        verbose_name = "Showcase Direto de Componentes"
-        verbose_name_plural = "Showcases Diretos de Componentes"
+        verbose_name = "Showcase Visual de Componentes"
+        verbose_name_plural = "Showcases Visuais de Componentes"
     
     def get_context(self, request):
         context = super().get_context(request)
+        debug_log = []
         
         try:
-            # Organizar componentes por categoria
-            categories_with_components = self.get_rendered_categories()
+            # Importar LAYOUT_STREAMBLOCKS
+            debug_log.append("Importando LAYOUT_STREAMBLOCKS...")
+            
+            try:
+                from .blocks import LAYOUT_STREAMBLOCKS
+                debug_log.append(f"✅ Importado: {len(LAYOUT_STREAMBLOCKS)} categorias")
+            except Exception as e:
+                debug_log.append(f"❌ Erro de import: {str(e)}")
+                raise Exception(f"Erro ao importar LAYOUT_STREAMBLOCKS: {str(e)}")
+            
+            # Descobrir e renderizar componentes COMPLETOS
+            categories_with_components = self.discover_and_render_complete_components(LAYOUT_STREAMBLOCKS, debug_log)
+            
+            # Aplicar filtros
+            if self.filter_category:
+                categories_with_components = {
+                    k: v for k, v in categories_with_components.items() 
+                    if k == self.filter_category
+                }
+                debug_log.append(f"Filtro aplicado: {self.filter_category}")
+            
+            if self.show_errors_only:
+                filtered_categories = {}
+                for cat_name, cat_data in categories_with_components.items():
+                    error_components = [c for c in cat_data['rendered_components'] if c.get('has_error', False)]
+                    if error_components:
+                        cat_data_copy = cat_data.copy()
+                        cat_data_copy['rendered_components'] = error_components
+                        filtered_categories[cat_name] = cat_data_copy
+                categories_with_components = filtered_categories
+                debug_log.append("Filtro de erros aplicado")
+            
+            # Calcular estatísticas
+            total_components = sum(len(cat['rendered_components']) for cat in categories_with_components.values())
+            components_ok = sum(
+                len([c for c in cat['rendered_components'] if not c.get('has_error', False)]) 
+                for cat in categories_with_components.values()
+            )
+            components_error = total_components - components_ok
             
             context.update({
                 'categories_with_components': categories_with_components,
-                'total_components': sum(len(cat['rendered_components']) for cat in categories_with_components.values()),
+                'total_components': total_components,
+                'components_ok': components_ok,
+                'components_error': components_error,
                 'total_categories': len(categories_with_components),
-                'page_title': 'Showcase Direto - Componentes ENAP',
-                'page_description': 'Visualização direta dos componentes com valores padrão'
+                'page_title': 'Showcase Visual - Componentes ENAP',
+                'page_description': 'Visualização estética dos componentes do Design System',
+                'debug_log': debug_log if self.debug_mode else [],
+                'debug_mode': self.debug_mode,
+                'available_categories': [name for name, _ in LAYOUT_STREAMBLOCKS],
             })
+            
         except Exception as e:
+            debug_log.append(f"❌ ERRO GERAL: {str(e)}")
+            debug_log.append(f"Traceback: {traceback.format_exc()}")
+            logger.error(f"Erro no showcase: {e}", exc_info=True)
+            
             context.update({
                 'error_message': f'Erro ao carregar componentes: {str(e)}',
                 'categories_with_components': {},
                 'total_components': 0,
+                'components_ok': 0,
+                'components_error': 0,
                 'total_categories': 0,
+                'debug_log': debug_log,
+                'debug_mode': self.debug_mode,
+                'available_categories': [],
             })
             
         return context
     
-    def get_rendered_categories(self):
-        """Retorna categorias com componentes já renderizados"""
+    def discover_and_render_complete_components(self, layout_streamblocks, debug_log):
+        """Descobre e renderiza componentes COMPLETOS, não os campos individuais"""
         categories = {}
-        layout_streamblocks = LAYOUT_STREAMBLOCKS
-        
-        # Mapeamento de ícones
-        category_icons = {
-            'banners': 'image',
-            'galerias': 'images', 
-            'carousels': 'arrows-up-down',
-            'dashboards': 'bar-chart',
-            'formularios': 'form',
-            'cursos': 'graduation-cap',
-            'eventos': 'calendar',
-            'navegacao': 'bars',
-            'menus': 'list-ul',
-            'botoes': 'mouse-pointer',
-            'conteudo': 'file-text',
-            'secoes': 'th-large',
-            'cards': 'clone',
-            'interativos': 'cogs',
-            'midia': 'play-circle',
-            'especialidades': 'puzzle-piece',
-        }
-        
-        # Descrições das categorias
-        category_descriptions = {
-            'banners': 'Componentes para banners, heroes e seções de destaque visual',
-            'galerias': 'Componentes para exibição de imagens, galerias e portfolios',
-            'carousels': 'Componentes de carrosséis, sliders e apresentações rotativas',
-            'dashboards': 'Componentes para dashboards, KPIs, métricas e visualização de dados',
-            'formularios': 'Componentes de formulários, campos de entrada e interação',
-            'cursos': 'Componentes específicos para cursos, educação e capacitação',
-            'eventos': 'Componentes para eventos, cronogramas, timelines e agenda',
-            'navegacao': 'Componentes de navegação, menus e estrutura de site',
-            'menus': 'Componentes de menu e navegação',
-            'botoes': 'Componentes de botões, call-to-actions e elementos clicáveis',
-            'conteudo': 'Componentes de conteúdo, texto rico, citações e mídia',
-            'secoes': 'Componentes de seções, containers e estruturas de layout',
-            'cards': 'Componentes de cards, grids e elementos organizacionais',
-            'interativos': 'Componentes interativos, acordeões, modais e elementos dinâmicos',
-            'midia': 'Componentes de vídeo, áudio, podcasts e conteúdo multimídia',
-            'especialidades': 'Componentes especializados e funcionalidades específicas da ENAP',
-        }
+        debug_log.append("\n=== DESCOBRINDO COMPONENTES COMPLETOS ===")
         
         for stream_name, stream_block in layout_streamblocks:
-            # Pular categorias complexas
-            if stream_name in ['enap_section', 'recaptcha']:
-                continue
+            debug_log.append(f"\nProcessando categoria: {stream_name}")
             
-            if not hasattr(stream_block, 'child_blocks'):
+            # Pular categorias que são muito complexas ou não visuais
+            if self.should_skip_category(stream_name):
+                debug_log.append(f"  ⏭️ Pulando categoria complexa: {stream_name}")
                 continue
-                
+            
+            # Criar categoria
             category_info = {
                 'name': stream_name,
-                'display_name': self.get_category_display_name(stream_block, stream_name),
-                'icon': category_icons.get(stream_name, 'cube'),
-                'description': category_descriptions.get(stream_name, f'Componentes da categoria {stream_name}'),
+                'display_name': self.format_category_name(stream_name),
+                'icon': self.get_category_icon(stream_name),
+                'description': self.get_category_description(stream_name),
                 'rendered_components': []
             }
             
-            # Renderizar cada componente da categoria
-            for component_name, component_block in stream_block.child_blocks.items():
-                rendered_component = self.render_component_with_defaults(
-                    component_name, component_block, stream_name
+            # Extrair componentes da categoria
+            if hasattr(stream_block, 'child_blocks') and stream_block.child_blocks:
+                debug_log.append(f"  📦 Categoria com {len(stream_block.child_blocks)} componentes")
+                
+                for comp_name, comp_block in stream_block.child_blocks.items():
+                    debug_log.append(f"    🔧 Renderizando: {comp_name}")
+                    
+                    # Renderizar o componente COMPLETO
+                    rendered_comp = self.render_complete_component(
+                        comp_name, comp_block, stream_name, debug_log
+                    )
+                    
+                    if rendered_comp:
+                        category_info['rendered_components'].append(rendered_comp)
+                        status = "❌" if rendered_comp.get('has_error') else "✅"
+                        debug_log.append(f"      {status} Adicionado")
+                    else:
+                        debug_log.append(f"      ❌ Falhou completamente")
+            
+            elif self.is_single_renderable_component(stream_block):
+                # Se a categoria é um componente único
+                debug_log.append(f"  🎯 Categoria é componente único")
+                rendered_comp = self.render_complete_component(
+                    stream_name, stream_block, stream_name, debug_log
                 )
-                if rendered_component:
-                    category_info['rendered_components'].append(rendered_component)
+                if rendered_comp:
+                    category_info['rendered_components'].append(rendered_comp)
+            
+            else:
+                debug_log.append(f"  ⚠️ Categoria não processável: {stream_block.__class__.__name__}")
             
-            # Só adicionar categoria se tiver componentes renderizados
+            # Adicionar categoria se tiver componentes
             if category_info['rendered_components']:
                 categories[stream_name] = category_info
+                debug_log.append(f"  ✅ Categoria adicionada com {len(category_info['rendered_components'])} componentes")
+            else:
+                debug_log.append(f"  ❌ Categoria ignorada (sem componentes)")
         
+        debug_log.append(f"\n📊 TOTAL: {len(categories)} categorias processadas")
         return categories
     
-    def get_category_display_name(self, stream_block, stream_name):
-        """Obtém nome de exibição da categoria"""
-        try:
-            category_meta = getattr(stream_block.__class__, 'Meta', None)
-            if category_meta and hasattr(category_meta, 'label'):
-                return category_meta.label
-        except:
-            pass
+    def should_skip_category(self, stream_name):
+        """Determina se deve pular uma categoria"""
+        skip_list = [
+            'enap_section',  # Muito complexa
+            'recaptcha',     # Não visual
+        ]
+        return stream_name in skip_list
+    
+    def is_single_renderable_component(self, block):
+        """Verifica se o bloco é um componente único renderizável"""
+        class_name = block.__class__.__name__
         
-        return stream_name.replace('_', ' ').title()
+        # Se termina com Block e tem método render, é renderizável
+        if class_name.endswith('Block') and hasattr(block, 'render'):
+            return True
+        
+        return False
     
-    def render_component_with_defaults(self, component_name, component_block, category_name):
-        """Renderiza um componente usando valores padrão"""
+    def render_complete_component(self, comp_name, comp_block, category_name, debug_log):
+        """Renderiza um componente COMPLETO com dados realistas"""
         try:
-            # Gerar dados padrão inteligentes
-            default_data = self.get_smart_defaults(component_name, component_block)
+            debug_log.append(f"      🎨 Tipo: {comp_block.__class__.__name__}")
+            
+            component_data = self.generate_realistic_component_data(comp_name, comp_block, debug_log)
             
-            # Tentar renderizar
             try:
-                rendered_html = component_block.render(default_data)
-            except Exception as render_error:
-                # Se falhar com dados padrão, tentar sem dados
+                if hasattr(comp_block, 'child_blocks'):
+                    for field_name, field_block in comp_block.child_blocks.items():
+                        if field_name in component_data:
+                            field_type = field_block.__class__.__name__
+                            value = component_data[field_name]
+                            
+                            if 'Stream' in field_type and not isinstance(value, list):
+                                component_data[field_name] = []
+                                debug_log.append(f"         🔧 Corrigido {field_name}: StreamBlock precisa de lista")
+                            
+                            elif 'List' in field_type and not isinstance(value, list):
+                                component_data[field_name] = []
+                                debug_log.append(f"         🔧 Corrigido {field_name}: ListBlock precisa de lista")
+                            
+                            elif 'Choice' in field_type and not isinstance(value, str):
+                                component_data[field_name] = 'opcao1'
+                                debug_log.append(f"         🔧 Corrigido {field_name}: ChoiceBlock precisa de string")
+                            
+                            elif 'RichText' in field_type and not isinstance(value, str):
+                                component_data[field_name] = '<p>Texto exemplo</p>'
+                                debug_log.append(f"         🔧 Corrigido {field_name}: RichText precisa de string")
+            
+            except Exception as validation_error:
+                debug_log.append(f"         ⚠️ Erro na validação: {str(validation_error)}")
+                component_data = {}
+            
+            rendered_html = None
+            render_error = None
+
+            try:
+                debug_log.append(f"      🎯 Tentando renderizar componente completo...")
+                rendered_html = comp_block.render(component_data)
+                debug_log.append(f"      ✅ Renderizado com sucesso ({len(rendered_html)} chars)")
+                has_error = False
+            except Exception as e:
+                debug_log.append(f"      ❌ Erro na renderização: {str(e)}")
+                render_error = str(e)
+                
                 try:
-                    rendered_html = component_block.render({})
-                except:
-                    # Se ainda falhar, criar um placeholder
-                    rendered_html = f'<div style="padding: 1rem; background: #f3f4f6; border-radius: 8px; text-align: center; color: #6b7280;"><p>Componente {component_name}</p><small>Erro na renderização: {str(render_error)}</small></div>'
+                    debug_log.append(f"      🔄 Tentando com dados mínimos...")
+                    minimal_data = self.generate_minimal_component_data(comp_block)
+                    rendered_html = comp_block.render(minimal_data)
+                    debug_log.append(f"      ✅ Renderizado com dados mínimos")
+                    has_error = False
+                except Exception as e2:
+                    debug_log.append(f"      ❌ Falhou também com dados mínimos: {str(e2)}")
+                    rendered_html = self.create_visual_placeholder(comp_name, category_name, str(e))
+                    has_error = True
             
             return {
-                'name': component_name,
-                'display_name': self.get_component_display_name(component_block),
-                'class_name': component_block.__class__.__name__,
+                'name': comp_name,
+                'display_name': self.get_component_display_name(comp_block, comp_name),
+                'class_name': comp_block.__class__.__name__,
                 'rendered_html': rendered_html,
                 'category_name': category_name,
-                'has_error': 'Erro na renderização' in rendered_html,
-                'field_count': len(getattr(component_block, 'child_blocks', {}))
+                'has_error': has_error,
+                'error_message': render_error if has_error else None,
+                'data_used': component_data if self.debug_mode else {},
             }
             
         except Exception as e:
-            print(f"Erro ao processar componente {component_name}: {e}")
+            debug_log.append(f"      💥 ERRO GERAL: {str(e)}")
             return None
     
-    def get_component_display_name(self, component_block):
-        """Obtém nome de exibição do componente"""
-        if hasattr(component_block, 'label') and component_block.label:
-            label = component_block.label
-            # Remove emojis do início
-            if any(label.startswith(emoji) for emoji in ['🎯', '🎨', '🏢', '🚀', '🔍', '📑', '🖼️', '⭐', '🎬']):
-                parts = label.split(' ', 1)
-                if len(parts) > 1:
-                    return parts[1]
-            return label
+    def generate_realistic_component_data(self, comp_name, comp_block, debug_log):
+        """Gera dados realistas para renderização visual completa"""
+        if not hasattr(comp_block, 'child_blocks'):
+            return {}
+        
+        data = {}
+        debug_log.append(f"        📝 Gerando dados para {len(comp_block.child_blocks)} campos")
+        
+        for field_name, field_block in comp_block.child_blocks.items():
+            value = self.generate_realistic_field_value(field_name, field_block, comp_name)
+            data[field_name] = value
+            
+            if self.debug_mode:
+                debug_log.append(f"          {field_name}: {str(value)[:50]}...")
         
-        return component_block.__class__.__name__.replace('Block', '').replace('_', ' ')
+        return data
     
-    def get_smart_defaults(self, component_name, component_block):
-        """Gera valores padrão inteligentes para o componente"""
-        defaults = {}
+    def generate_realistic_field_value(self, field_name, field_block, comp_name):
+        """Gera valores realistas baseados no contexto ENAP com defaults específicos por tipo"""
+        field_type = field_block.__class__.__name__
+        field_lower = field_name.lower()
+        
+        # Usar default se existir
+        if hasattr(field_block, 'default') and field_block.default is not None:
+            return field_block.default
+        
+        # DEFAULTS ESPECÍFICOS POR TIPO DE CAMPO
+        
+        # === IMAGENS ===
+        if field_type in ['ImageChooserBlock', 'ImageBlock']:
+            return self.get_default_image_value(field_name)
+        
+        # === DOCUMENTOS ===
+        elif field_type in ['DocumentChooserBlock', 'DocumentBlock']:
+            return self.get_default_document_value(field_name)
+        
+        # === PÁGINAS ===
+        elif field_type in ['PageChooserBlock', 'PageBlock']:
+            return self.get_default_page_value(field_name)
+        
+        # === SNIPPETS ===
+        elif field_type in ['SnippetChooserBlock']:
+            return None  # Snippets são mais complexos, deixar vazio
         
-        if not hasattr(component_block, 'child_blocks'):
-            return defaults
+        # === BLOCOS ESTRUTURADOS ===
+        elif field_type == 'StructBlock':
+            return {}  # Será processado recursivamente
+        
+        elif field_type == 'ListBlock':
+            return self.generate_listblock_default_data(field_block, field_name)
+        
+        elif field_type == 'StreamBlock':
+            return self.generate_streamblock_default_data(field_block, field_name)
+        
+        # === CAMPOS DE ESCOLHA ===
+        elif field_type == 'ChoiceBlock':
+            return self.get_choice_default_value(field_block, field_name)
+        
+        # === CAMPOS BÁSICOS ===
+        elif field_type == 'BooleanBlock':
+            return self.get_boolean_default_value(field_name)
+        
+        elif field_type in ['IntegerBlock', 'FloatBlock', 'DecimalBlock']:
+            return self.get_numeric_default_value(field_name, field_type)
+        
+        elif field_type in ['DateBlock', 'TimeBlock', 'DateTimeBlock']:
+            return self.get_datetime_default_value(field_type)
+        
+        elif field_type == 'RichTextBlock':
+            return self.get_richtext_default_value(field_name)
+        
+        elif field_type in ['URLBlock']:
+            return self.get_url_default_value(field_name)
+        
+        elif field_type == 'EmailBlock':
+            return self.get_email_default_value(field_name)
+        
+        elif field_type in ['TextBlock', 'CharBlock']:
+            return self.get_text_default_value(field_name, field_lower)
+        
+        elif field_type == 'RegexBlock':
+            return 'ABC123'  # Valor que geralmente passa em regex básicas
+        
+        elif field_type == 'RawHTMLBlock':
+            return '<div class="exemplo">Conteúdo HTML de exemplo</div>'
+        
+        # === BLOCOS CUSTOMIZADOS ===
+        elif 'Color' in field_type:
+            return '#3B82F6'  # Azul padrão
+        
+        elif 'Icon' in field_type:
+            return 'fas fa-star'  # Ícone padrão
+        
+        # Valor padrão genérico
+        return f'Exemplo ENAP - {field_name}'
+    
+    def get_default_image_value(self, field_name):
+        """Gera valor padrão para campos de imagem"""
+        from wagtail.images.models import Image
+        
+        # Tentar encontrar uma imagem existente no sistema
+        try:
+            # Buscar por imagens que possam ser usadas como placeholder
+            placeholder_images = Image.objects.filter(
+                title__icontains='placeholder'
+            ).first()
             
-        for field_name, field_block in component_block.child_blocks.items():
-            field_type = field_block.__class__.__name__
+            if placeholder_images:
+                return placeholder_images
             
-            # Usar valor padrão do campo se existir
-            if hasattr(field_block, 'default') and field_block.default is not None:
-                defaults[field_name] = field_block.default
-                continue
+            # Buscar por imagens com nomes genéricos
+            generic_names = ['exemplo', 'sample', 'test', 'demo', 'enap', 'logo']
+            for name in generic_names:
+                image = Image.objects.filter(title__icontains=name).first()
+                if image:
+                    return image
             
-            # Gerar valores contextuais baseados no nome do campo
-            field_lower = field_name.lower()
+            # Se não encontrar, usar qualquer imagem
+            any_image = Image.objects.first()
+            if any_image:
+                return any_image
+                
+        except Exception:
+            pass
+        
+        # Se não houver imagens, criar uma imagem placeholder via código
+        return self.create_placeholder_image_object(field_name)
+    
+    def create_placeholder_image_object(self, field_name):
+        """Cria um objeto placeholder para representar uma imagem"""
+        # Como não podemos criar imagens reais sem arquivos, 
+        # retornamos None e deixamos o template lidar com isso
+        # O template deve mostrar um placeholder visual
+        return None
+    
+    def get_default_document_value(self, field_name):
+        """Gera valor padrão para campos de documento"""
+        from wagtail.documents.models import Document
+        
+        try:
+            # Buscar documento de exemplo
+            example_doc = Document.objects.filter(
+                title__icontains='exemplo'
+            ).first()
+            
+            if example_doc:
+                return example_doc
+            
+            # Qualquer documento
+            any_doc = Document.objects.first()
+            if any_doc:
+                return any_doc
+                
+        except Exception:
+            pass
+        
+        return None
+    
+    def get_default_page_value(self, field_name):
+        """Gera valor padrão para campos de página"""
+        from wagtail.models import Page
+        
+        try:
+            # Buscar página home ou root
+            home_page = Page.objects.filter(
+                slug__in=['home', 'inicio', 'root']
+            ).first()
+            
+            if home_page:
+                return home_page
+            
+            # Qualquer página que não seja root
+            any_page = Page.objects.filter(depth__gt=1).first()
+            if any_page:
+                return any_page
+                
+        except Exception:
+            pass
+        
+        return None
+    
+    def get_choice_default_value(self, field_block, field_name):
+        """Gera valor padrão para campos de escolha"""
+        try:
+            if hasattr(field_block, 'choices') and field_block.choices:
+                # Retornar a primeira opção
+                return field_block.choices[0][0]
+        except Exception:
+            pass
+        
+        return 'opcao1'
+    
+    def get_boolean_default_value(self, field_name):
+        """Gera valor padrão para campos boolean"""
+        field_lower = field_name.lower()
+        
+        # Campos que geralmente são False por padrão
+        false_defaults = [
+            'disable', 'hidden', 'private', 'draft', 'inactive',
+            'closed', 'locked', 'disabled', 'hide'
+        ]
+        
+        for false_word in false_defaults:
+            if false_word in field_lower:
+                return False
+        
+        # Maioria dos booleans são True para melhor visualização
+        return True
+    
+    def get_numeric_default_value(self, field_name, field_type):
+        """Gera valor padrão para campos numéricos"""
+        field_lower = field_name.lower()
+        
+        # Valores específicos baseados no nome
+        if 'price' in field_lower or 'preco' in field_lower:
+            return 299.90 if field_type == 'FloatBlock' else 299
+        elif 'year' in field_lower or 'ano' in field_lower:
+            return 2024
+        elif 'month' in field_lower or 'mes' in field_lower:
+            return 6
+        elif 'day' in field_lower or 'dia' in field_lower:
+            return 15
+        elif 'hour' in field_lower or 'hora' in field_lower:
+            return 14
+        elif 'minute' in field_lower or 'minuto' in field_lower:
+            return 30
+        elif 'percent' in field_lower or 'porcentagem' in field_lower:
+            return 85.5 if field_type == 'FloatBlock' else 85
+        elif 'count' in field_lower or 'total' in field_lower:
+            return 42
+        elif 'order' in field_lower or 'ordem' in field_lower:
+            return 1
+        
+        # Valor padrão genérico
+        return 100.0 if field_type == 'FloatBlock' else 100
+    
+    def get_datetime_default_value(self, field_type):
+        """Gera valor padrão para campos de data/hora"""
+        if field_type == 'DateBlock':
+            return '2024-06-15'
+        elif field_type == 'TimeBlock':
+            return '14:30:00'
+        elif field_type == 'DateTimeBlock':
+            return '2024-06-15T14:30:00'
+        
+        return '2024-06-15'
+	
+    def generate_streamblock_default_data(self, stream_block, field_name):
+        """Gera dados padrão para StreamBlocks"""
+        if not hasattr(stream_block, 'child_blocks'):
+            return []
+        
+        stream_data = []
+        available_blocks = list(stream_block.child_blocks.items())[:2]
+        
+        for block_name, block_instance in available_blocks:
+            if hasattr(block_instance, 'child_blocks'):
+                block_data = {}
+                for child_field, child_block in block_instance.child_blocks.items():
+                    block_data[child_field] = self.generate_realistic_field_value(
+                        child_field, child_block, f"{field_name}_{block_name}"
+                    )
+            else:
+                block_data = self.generate_realistic_field_value(
+                    block_name, block_instance, field_name
+                )
+            
+            stream_data.append({
+                'type': block_name,
+                'value': block_data
+            })
+        
+        return stream_data
+
+    def generate_listblock_default_data(self, field_block, field_name):
+        """Gera dados padrão para ListBlocks"""
+        if hasattr(field_block, 'child_block'):
+            child_block = field_block.child_block
+            items = []
+            
+            for i in range(2):
+                if hasattr(child_block, 'child_blocks'):
+                    item_data = {}
+                    for sub_field, sub_block in child_block.child_blocks.items():
+                        item_data[sub_field] = self.generate_realistic_field_value(
+                            sub_field, sub_block, f"{field_name}_item_{i}"
+                        )
+                else:
+                    item_data = self.generate_realistic_field_value(
+                        f"{field_name}_item_{i}", child_block, f"{field_name}_list"
+                    )
+                items.append(item_data)
             
-            if 'title' in field_lower or 'titulo' in field_lower:
-                defaults[field_name] = 'Escola Nacional de Administração Pública'
-            elif 'subtitle' in field_lower or 'subtitulo' in field_lower:
-                defaults[field_name] = 'Excelência em capacitação para o serviço público'
-            elif 'text' in field_lower or 'texto' in field_lower:
-                defaults[field_name] = 'A ENAP é responsável pela capacitação de servidores públicos federais, contribuindo para a modernização da administração pública.'
-            elif 'description' in field_lower or 'descricao' in field_lower:
-                defaults[field_name] = 'Componente do Design System ENAP para construção de interfaces modernas.'
-            elif 'button' in field_lower or 'botao' in field_lower:
-                defaults[field_name] = 'Saiba Mais'
-            elif 'url' in field_lower or 'link' in field_lower:
-                defaults[field_name] = 'https://www.enap.gov.br'
-            elif 'email' in field_lower:
-                defaults[field_name] = 'contato@enap.gov.br'
+            return items
+        
+        return []
+    
+    def get_richtext_default_value(self, field_name):
+        """Gera valor padrão para campos de texto rico"""
+        field_lower = field_name.lower()
+        
+        # Conteúdos específicos baseados no nome do campo
+        if 'about' in field_lower or 'sobre' in field_lower:
+            return '''
+            <h3>Sobre a ENAP</h3>
+            <p>A <strong>Escola Nacional de Administração Pública</strong> é responsável pela capacitação e desenvolvimento de servidores públicos federais.</p>
+            <ul>
+                <li>Cursos presenciais e à distância</li>
+                <li>Eventos e seminários</li>
+                <li>Pesquisas em gestão pública</li>
+            </ul>
+            '''
+        elif 'content' in field_lower or 'conteudo' in field_lower:
+            return '''
+            <h2>Modernização da Gestão Pública</h2>
+            <p>A ENAP promove a <em>excelência na administração pública</em> através de:</p>
+            <ol>
+                <li><strong>Capacitação continuada</strong> de servidores</li>
+                <li><strong>Pesquisa aplicada</strong> em gestão pública</li>
+                <li><strong>Inovação</strong> em processos governamentais</li>
+            </ol>
+            <blockquote>
+                <p>"Transformando a administração pública através do conhecimento"</p>
+            </blockquote>
+            '''
+        elif 'description' in field_lower or 'descricao' in field_lower:
+            return '''
+            <p>Desenvolvemos <strong>competências e habilidades</strong> dos servidores para uma gestão pública moderna, eficiente e orientada ao cidadão.</p>
+            <p>Nossa missão é contribuir para a modernização do Estado através da capacitação de seus servidores.</p>
+            '''
+        
+        # Conteúdo padrão genérico
+        return '''
+        <h3>Título de Exemplo</h3>
+        <p>Este é um conteúdo de <strong>exemplo</strong> em texto rico para demonstrar a funcionalidade do componente.</p>
+        <p>Inclui <em>formatação básica</em> e <a href="https://www.enap.gov.br">links externos</a>.</p>
+        '''
+    
+    def get_url_default_value(self, field_name):
+        """Gera valor padrão para campos de URL"""
+        field_lower = field_name.lower()
+        
+        # URLs específicas baseadas no nome do campo
+        url_mapping = {
+            'site': 'https://www.enap.gov.br',
+            'home': 'https://www.enap.gov.br',
+            'curso': 'https://www.enap.gov.br/cursos',
+            'course': 'https://www.enap.gov.br/cursos',
+            'event': 'https://www.enap.gov.br/eventos',
+            'evento': 'https://www.enap.gov.br/eventos',
+            'news': 'https://www.enap.gov.br/noticias',
+            'noticia': 'https://www.enap.gov.br/noticias',
+            'contact': 'https://www.enap.gov.br/contato',
+            'contato': 'https://www.enap.gov.br/contato',
+            'blog': 'https://www.enap.gov.br/blog',
+            'video': 'https://www.youtube.com/watch?v=example',
+            'youtube': 'https://www.youtube.com/watch?v=example',
+            'social': 'https://www.linkedin.com/company/enap',
+            'linkedin': 'https://www.linkedin.com/company/enap',
+            'facebook': 'https://www.facebook.com/enap.oficial',
+            'twitter': 'https://twitter.com/enap_oficial',
+            'instagram': 'https://instagram.com/enap_oficial',
+        }
+        
+        for key, url in url_mapping.items():
+            if key in field_lower:
+                return url
+        
+        # URL padrão
+        return 'https://www.enap.gov.br'
+    
+    def get_email_default_value(self, field_name):
+        """Gera valor padrão para campos de email"""
+        field_lower = field_name.lower()
+        
+        # Emails específicos baseados no nome do campo
+        email_mapping = {
+            'contact': 'contato@enap.gov.br',
+            'contato': 'contato@enap.gov.br',
+            'support': 'suporte@enap.gov.br',
+            'suporte': 'suporte@enap.gov.br',
+            'admin': 'admin@enap.gov.br',
+            'curso': 'cursos@enap.gov.br',
+            'course': 'cursos@enap.gov.br',
+            'event': 'eventos@enap.gov.br',
+            'evento': 'eventos@enap.gov.br',
+            'news': 'noticias@enap.gov.br',
+            'noticia': 'noticias@enap.gov.br',
+            'inscricao': 'inscricoes@enap.gov.br',
+            'registration': 'inscricoes@enap.gov.br',
+        }
+        
+        for key, email in email_mapping.items():
+            if key in field_lower:
+                return email
+        
+        # Email padrão
+        return 'contato@enap.gov.br'
+    
+    def get_text_default_value(self, field_name, field_lower):
+        """Gera valor padrão para campos de texto"""
+        # Conteúdos específicos da ENAP baseados no nome do campo
+        
+        if 'title' in field_lower or 'titulo' in field_lower:
+            titles = [
+                'Escola Nacional de Administração Pública',
+                'Capacitação para o Serviço Público',
+            ]
+            import random
+            return random.choice(titles)
+            
+        elif 'subtitle' in field_lower or 'subtitulo' in field_lower:
+            return 'Excelência em capacitação para o serviço público'
+            
+        elif 'description' in field_lower or 'descricao' in field_lower:
+            descriptions = [
+                'A ENAP é a escola de governo do Poder Executivo federal, responsável pela formação e capacitação de servidores públicos.'
+            ]
+            import random
+            return random.choice(descriptions)
+            
+        elif 'button' in field_lower or 'botao' in field_lower or 'cta' in field_lower:
+            buttons = ['Saiba Mais', 'Inscreva-se', 'Conheça', 'Participe', 'Acesse', 'Baixar', 'Ver Mais']
+            import random
+            return random.choice(buttons)
+            
+        elif 'name' in field_lower or 'nome' in field_lower:
+            return 'ENAP - Escola Nacional de Administração Pública'
+            
+        elif 'author' in field_lower or 'autor' in field_lower:
+            return 'Equipe ENAP'
+            
+        elif 'phone' in field_lower or 'telefone' in field_lower:
+            return '(61) 2020-3000'
+            
+        elif 'address' in field_lower or 'endereco' in field_lower:
+            return 'SAIS - Área 2-A - Brasília/DF - CEP: 70610-900'
+            
+        elif 'city' in field_lower or 'cidade' in field_lower:
+            return 'Brasília'
+            
+        elif 'state' in field_lower or 'estado' in field_lower:
+            return 'Distrito Federal'
+            
+        elif 'country' in field_lower or 'pais' in field_lower:
+            return 'Brasil'
+            
+        elif 'price' in field_lower or 'preco' in field_lower:
+            return 'Gratuito'
+            
+        elif 'duration' in field_lower or 'duracao' in field_lower:
+            return '40 horas'
+            
+        elif 'level' in field_lower or 'nivel' in field_lower:
+            return 'Intermediário'
+            
+        elif 'category' in field_lower or 'categoria' in field_lower:
+            return 'Gestão Pública'
+            
+        elif 'tag' in field_lower:
+            return 'capacitacao'
+            
+        elif 'slug' in field_lower:
+            return 'exemplo-componente-enap'
+        
+        # Valor padrão baseado no nome do campo
+        return f'Exemplo ENAP - {field_name.replace("_", " ").title()}'
+    
+    def generate_minimal_component_data(self, comp_block):
+        """Gera dados mínimos para fallback"""
+        if not hasattr(comp_block, 'child_blocks'):
+            return {}
+        
+        minimal = {}
+        for field_name, field_block in comp_block.child_blocks.items():
+            field_type = field_block.__class__.__name__
+            
+            if 'title' in field_name.lower():
+                minimal[field_name] = 'ENAP'
             elif field_type == 'BooleanBlock':
-                defaults[field_name] = True
+                minimal[field_name] = True
             elif field_type in ['IntegerBlock', 'FloatBlock']:
-                defaults[field_name] = 42
-            elif field_type == 'DateBlock':
-                defaults[field_name] = '2024-03-15'
-            elif field_type == 'RichTextBlock':
-                defaults[field_name] = '<p>Conteúdo de <strong>exemplo</strong> para demonstração do componente.</p>'
-            else:
-                # Valor genérico baseado no nome do campo
-                defaults[field_name] = f'Exemplo {field_name}'
+                minimal[field_name] = 1
+        
+        return minimal
+    
+    def create_visual_placeholder(self, comp_name, category_name, error_msg):
+        """Cria um placeholder visual para componentes com erro"""
+        return f'''
+        <div style="
+            padding: 2rem; 
+            background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%); 
+            border: 2px dashed #dc2626; 
+            border-radius: 12px; 
+            text-align: center; 
+            color: #7f1d1d; 
+            margin: 1rem 0;
+            box-shadow: 0 4px 8px rgba(220, 38, 38, 0.1);
+        ">
+            <div style="font-size: 2rem; margin-bottom: 0.5rem;">⚠️</div>
+            <h3 style="margin: 0 0 0.5rem 0; color: #dc2626; font-size: 1.25rem;">{comp_name}</h3>
+            <p style="margin: 0 0 0.5rem 0; font-size: 0.875rem;">Componente não pôde ser renderizado</p>
+            <small style="color: #991b1b; display: block;">Categoria: {category_name}</small>
+            {f'<details style="margin-top: 1rem;"><summary style="cursor: pointer;">Ver erro técnico</summary><div style="margin-top: 0.5rem; font-family: monospace; font-size: 0.75rem; text-align: left; background: rgba(0,0,0,0.1); padding: 0.5rem; border-radius: 4px;">{error_msg}</div></details>' if self.debug_mode else ''}
+        </div>
+        '''
+    
+    def get_component_display_name(self, block, comp_name):
+        """Nome de exibição limpo do componente"""
+        if hasattr(block, 'label') and block.label:
+            label = block.label
+            # Remove emojis do início
+            emoji_prefixes = ['🎯', '🎨', '🏢', '🚀', '🔍', '📑', '🖼️', '⭐', '🎬', '📋', '⚡', '📞', '👂']
+            for emoji in emoji_prefixes:
+                if label.startswith(emoji):
+                    parts = label.split(' ', 1)
+                    if len(parts) > 1:
+                        return parts[1]
+                    break
+            return label
         
-        return defaults
+        # Formatar nome da classe
+        class_name = block.__class__.__name__
+        if class_name.endswith('Block'):
+            class_name = class_name[:-5]
+        
+        return class_name.replace('_', ' ').title()
+    
+    def format_category_name(self, category_name):
+        """Formata nome da categoria"""
+        category_names = {
+            'banners': 'Banners e Heroes',
+            'galerias': 'Galerias e Imagens',
+            'carousels': 'Carrosséis',
+            'dashboards': 'Dashboards e Métricas',
+            'formularios': 'Formulários',
+            'cursos': 'Cursos e Educação',
+            'eventos': 'Eventos',
+            'navegacao': 'Navegação',
+            'menus': 'Menus',
+            'botoes': 'Botões e CTAs',
+            'conteudo': 'Conteúdo e Texto',
+            'secoes': 'Seções e Containers',
+            'cards': 'Cards',
+            'interativos': 'Componentes Interativos',
+            'midia': 'Mídia e Vídeos',
+            'especialidades': 'Componentes Especializados',
+        }
+        
+        return category_names.get(category_name, category_name.replace('_', ' ').title())
+    
+    def get_category_icon(self, category_name):
+        """Ícone da categoria"""
+        icons = {
+            'banners': 'image',
+            'galerias': 'images',
+            'carousels': 'arrows-up-down',
+            'dashboards': 'chart-bar',
+            'formularios': 'edit',
+            'cursos': 'graduation-cap',
+            'eventos': 'calendar',
+            'navegacao': 'bars',
+            'menus': 'list',
+            'botoes': 'mouse-pointer',
+            'conteudo': 'file-text',
+            'secoes': 'th-large',
+            'cards': 'clone',
+            'interativos': 'cogs',
+            'midia': 'play-circle',
+            'especialidades': 'puzzle-piece',
+        }
+        return icons.get(category_name, 'cube')
+    
+    def get_category_description(self, category_name):
+        """Descrição da categoria"""
+        descriptions = {
+            'banners': 'Componentes para seções de destaque, heroes e banners promocionais',
+            'galerias': 'Componentes para exibição de imagens, galerias e portfolios visuais',
+            'carousels': 'Componentes de carrosséis, sliders e apresentações rotativas',
+            'dashboards': 'Componentes para dashboards, KPIs, gráficos e visualização de dados',
+            'formularios': 'Componentes de formulários, campos de entrada e validação',
+            'cursos': 'Componentes específicos para cursos, educação e capacitação online',
+            'eventos': 'Componentes para eventos, cronogramas e calendários',
+            'navegacao': 'Componentes de navegação, menus e estruturas de site',
+            'menus': 'Componentes específicos de menu e navegação secundária',
+            'botoes': 'Componentes de botões, call-to-actions e elementos clicáveis',
+            'conteudo': 'Componentes de conteúdo, texto rico, citações e artigos',
+            'secoes': 'Componentes de seções, containers e estruturas de layout',
+            'cards': 'Componentes de cards, grids e elementos organizacionais',
+            'interativos': 'Componentes interativos, acordeões, modais e elementos dinâmicos',
+            'midia': 'Componentes de vídeo, áudio, podcasts e conteúdo multimídia',
+            'especialidades': 'Componentes especializados e funcionalidades específicas da ENAP',
+        }
+        return descriptions.get(category_name, f'Componentes da categoria {category_name}')