wagtail-enap-designsystem 1.2.1.121__py3-none-any.whl → 1.2.1.122__py3-none-any.whl

enap_designsystem/urls.py

@@ -39,7 +39,10 @@ urlpatterns = [
     path('reports/form/<int:page_id>/', views.form_report, name='form_report'),
 
     path('votar/', views.votar_projeto, name='votar_projeto'),
-    path('estatisticas/', views.estatisticas_votacao, name='estatisticas_votacao'),
-    path('ranking/', views.ranking_projetos, name='ranking_projetos'),
-    path('ranking/<int:categoria_id>/', views.ranking_projetos, name='ranking_projetos_categoria'),
+    
+    # URLs auxiliares de votação
+    path('api/estatisticas/', views.estatisticas_votacao, name='estatisticas_votacao'),
+    path('api/ranking/', views.ranking_projetos, name='ranking_projetos'),
+    path('api/ranking/<int:categoria_id>/', views.ranking_projetos, name='ranking_projetos_categoria'),
+    
 ]

enap_designsystem/views.py

@@ -2052,225 +2052,190 @@ def save_file_linked_to_form(uploaded_file, page_id, submission_id, field_name):
 
 
 
+# views.py - View corrigida para votação
 
-# views.py - Views completas do Sistema de Votação
-
-import json
 from django.http import JsonResponse
 from django.views.decorators.http import require_http_methods
-from django.shortcuts import get_object_or_404
-from django.utils import timezone
-from .models import ProjetoVotacao, VotoRegistrado, CategoriaVotacao
+from django.views.decorators.csrf import csrf_exempt
+from django.contrib.sessions.models import Session
+import json
+import logging
+
+logger = logging.getLogger(__name__)
 
 
-def get_client_ip(request):
-    """Extrai o IP real do cliente"""
-    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
-    if x_forwarded_for:
-        ip = x_forwarded_for.split(',')[0].strip()
-    else:
-        ip = request.META.get('REMOTE_ADDR')
-    return ip
 
+@require_http_methods(["POST"])
+@csrf_exempt
+# views.py - Versão simples sem restrições de tempo
 
 @require_http_methods(["POST"])
+@csrf_exempt
 def votar_projeto(request):
-    """
-    View AJAX para registrar voto em um projeto
-    """
+    """View simples para votação - sem restrições"""
+    
     try:
-        # Parse do JSON
-        data = json.loads(request.body)
+        logger.info(f"=== VOTAÇÃO ===")
+        
+        # Parse JSON
+        if not request.body:
+            return JsonResponse({
+                'success': False,
+                'message': 'Dados não fornecidos'
+            }, status=400)
+        
+        try:
+            data = json.loads(request.body)
+        except json.JSONDecodeError:
+            return JsonResponse({
+                'success': False,
+                'message': 'JSON inválido'
+            }, status=400)
+        
+        # Dados obrigatórios
         projeto_id = data.get('projeto_id')
         categoria_id = data.get('categoria_id')
         
         if not projeto_id or not categoria_id:
             return JsonResponse({
                 'success': False,
-                'message': 'Dados inválidos. Projeto e categoria são obrigatórios.'
+                'message': 'projeto_id e categoria_id são obrigatórios'
             }, status=400)
         
-        # Buscar projeto
-        projeto = get_object_or_404(ProjetoVotacao, id=projeto_id, ativo=True)
+        # Dados da requisição
+        ip_address = request.META.get('REMOTE_ADDR', 'unknown')
+        user_agent = request.META.get('HTTP_USER_AGENT', '')
+        
+        # Importar e validar
+        from .models import VotoRegistrado, ProjetoVotacao, CategoriaVotacao
         
-        # Verificar se o projeto pertence à categoria
-        if projeto.categoria.id != int(categoria_id):
+        try:
+            projeto = ProjetoVotacao.objects.get(id=projeto_id, ativo=True)
+            categoria = CategoriaVotacao.objects.get(id=categoria_id, ativo=True)
+        except (ProjetoVotacao.DoesNotExist, CategoriaVotacao.DoesNotExist):
             return JsonResponse({
                 'success': False,
-                'message': 'Projeto não pertence à categoria especificada.'
-            }, status=400)
-        
-        # Obter dados do request
-        ip_address = get_client_ip(request)
-        user_agent = request.META.get('HTTP_USER_AGENT', '')[:500]
+                'message': 'Projeto ou categoria não encontrados'
+            }, status=404)
         
-        # Registrar o voto
+        # REGISTRAR VOTO - SEM VERIFICAÇÕES DE DUPLICAÇÃO
         voto = VotoRegistrado.objects.create(
             projeto=projeto,
+            categoria_nome=categoria.nome,
             ip_address=ip_address,
-            user_agent=user_agent,
-            categoria_nome=projeto.categoria.nome
+            user_agent=user_agent[:500] if user_agent else ''
         )
         
-        # Resposta de sucesso
+        logger.info(f"Voto registrado: {voto.id}")
+        
+        # Estatísticas
+        total_votos_projeto = VotoRegistrado.objects.filter(projeto=projeto).count()
+        total_votos_categoria = VotoRegistrado.objects.filter(
+            projeto__categoria=categoria
+        ).count()
+        
         return JsonResponse({
             'success': True,
             'message': 'Voto registrado com sucesso!',
-            'voto_id': str(voto.id),
-            'projeto_id': projeto.id,
-            'categoria_id': projeto.categoria.id,
-            'total_votos': projeto.total_votos,
-            'timestamp': voto.timestamp.isoformat()
+            'voto_id': voto.id,
+            'total_votos': total_votos_projeto,
+            'total_votos_categoria': total_votos_categoria,
+            'projeto_titulo': projeto.titulo
         })
         
-    except json.JSONDecodeError:
-        return JsonResponse({
-            'success': False,
-            'message': 'Dados JSON inválidos.'
-        }, status=400)
-        
-    except ProjetoVotacao.DoesNotExist:
-        return JsonResponse({
-            'success': False,
-            'message': 'Projeto não encontrado ou inativo.'
-        }, status=404)
-        
     except Exception as e:
-        # Log do erro em produção
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.error(f"Erro ao processar voto: {str(e)}", exc_info=True)
-        
+        logger.error(f"Erro: {str(e)}", exc_info=True)
         return JsonResponse({
             'success': False,
-            'message': 'Erro interno do servidor. Tente novamente.'
+            'message': f'Erro interno: {str(e)}'
         }, status=500)
-
+# Views auxiliares também corrigidas
 
 @require_http_methods(["GET"])
 def estatisticas_votacao(request):
-    """
-    View AJAX para obter estatísticas da votação
-    """
+    """Estatísticas da votação"""
     try:
+        from .models import VotoRegistrado, CategoriaVotacao, ProjetoVotacao
+        from django.db.models import Count
+        
         # Estatísticas gerais
         total_votos = VotoRegistrado.objects.count()
-        total_projetos = ProjetoVotacao.objects.filter(ativo=True).count()
         total_categorias = CategoriaVotacao.objects.filter(ativo=True).count()
+        total_projetos = ProjetoVotacao.objects.filter(ativo=True).count()
         
-        # Estatísticas por categoria
-        categorias_stats = []
-        for categoria in CategoriaVotacao.objects.filter(ativo=True).order_by('ordem'):
-            projetos_categoria = categoria.projetos.filter(ativo=True)
-            votos_categoria = VotoRegistrado.objects.filter(projeto__in=projetos_categoria).count()
-            
-            # Projeto mais votado da categoria
-            projeto_top = None
-            if projetos_categoria.exists():
-                projeto_mais_votado = max(projetos_categoria, key=lambda p: p.total_votos)
-                if projeto_mais_votado.total_votos > 0:
-                    projeto_top = {
-                        'id': projeto_mais_votado.id,
-                        'titulo': projeto_mais_votado.titulo,
-                        'votos': projeto_mais_votado.total_votos
-                    }
-            
-            categorias_stats.append({
-                'id': categoria.id,
-                'nome': categoria.nome,
-                'total_projetos': projetos_categoria.count(),
-                'total_votos': votos_categoria,
-                'projeto_top': projeto_top
-            })
-        
-        # Projetos mais votados (top 5)
-        projetos_top = []
-        for projeto in ProjetoVotacao.objects.filter(ativo=True):
-            projetos_top.append({
-                'id': projeto.id,
-                'titulo': projeto.titulo,
-                'categoria': projeto.categoria.nome,
-                'votos': projeto.total_votos
-            })
+        # Votos por categoria (usando relacionamento)
+        votos_categoria = (VotoRegistrado.objects
+                          .values('projeto__categoria__nome', 'projeto__categoria__id')
+                          .annotate(total=Count('id'))
+                          .order_by('-total'))
         
-        # Ordenar por votos (descending)
-        projetos_top = sorted(projetos_top, key=lambda p: p['votos'], reverse=True)[:5]
+        # Projetos mais votados
+        projetos_top = (VotoRegistrado.objects
+                       .values('projeto__titulo', 'projeto__id', 'projeto__categoria__nome')
+                       .annotate(total=Count('id'))
+                       .order_by('-total')[:10])
         
         return JsonResponse({
             'success': True,
-            'data': {
-                'resumo': {
-                    'total_votos': total_votos,
-                    'total_projetos': total_projetos,
-                    'total_categorias': total_categorias
-                },
-                'categorias': categorias_stats,
-                'projetos_top': projetos_top,
-                'timestamp': timezone.now().isoformat()
+            'estatisticas': {
+                'total_votos': total_votos,
+                'total_categorias': total_categorias,
+                'total_projetos': total_projetos,
+                'votos_por_categoria': list(votos_categoria),
+                'projetos_mais_votados': list(projetos_top)
             }
         })
         
     except Exception as e:
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.error(f"Erro ao obter estatísticas: {str(e)}", exc_info=True)
-        
+        logger.error(f"Erro estatísticas: {e}")
         return JsonResponse({
             'success': False,
-            'message': 'Erro ao obter estatísticas.'
+            'message': 'Erro ao buscar estatísticas'
         }, status=500)
 
 
-@require_http_methods(["GET"])  
+@require_http_methods(["GET"])
 def ranking_projetos(request, categoria_id=None):
-    """
-    View AJAX para obter ranking de projetos
-    """
+    """Ranking de projetos por categoria"""
     try:
-        # Filtrar por categoria se especificado
-        if categoria_id:
-            categoria = get_object_or_404(CategoriaVotacao, id=categoria_id, ativo=True)
-            projetos = ProjetoVotacao.objects.filter(categoria=categoria, ativo=True)
-        else:
-            projetos = ProjetoVotacao.objects.filter(ativo=True)
-        
-        # Criar lista com dados dos projetos
-        ranking = []
-        for projeto in projetos:
-            ranking.append({
-                'id': projeto.id,
-                'titulo': projeto.titulo,
-                'categoria': projeto.categoria.nome,
-                'equipe': projeto.nome_equipe,
-                'total_votos': projeto.total_votos,
-                'destacado': projeto.destacado
-            })
+        from .models import VotoRegistrado, ProjetoVotacao, CategoriaVotacao
+        from django.db.models import Count
         
-        # Ordenar por votos (descending)
-        ranking.sort(key=lambda p: p['total_votos'], reverse=True)
+        # Base query
+        queryset = VotoRegistrado.objects.select_related('projeto', 'projeto__categoria')
+        
+        # Filtrar por categoria se fornecida
+        if categoria_id:
+            try:
+                categoria = CategoriaVotacao.objects.get(id=categoria_id, ativo=True)
+                queryset = queryset.filter(projeto__categoria=categoria)
+            except CategoriaVotacao.DoesNotExist:
+                return JsonResponse({
+                    'success': False,
+                    'message': 'Categoria não encontrada'
+                }, status=404)
+        
+        # Ranking
+        ranking = (queryset
+                  .values(
+                      'projeto__id', 
+                      'projeto__titulo', 
+                      'projeto__categoria__nome',
+                      'projeto__categoria__id',
+                      'projeto__nome_equipe'
+                  )
+                  .annotate(total_votos=Count('id'))
+                  .order_by('-total_votos'))
         
         return JsonResponse({
             'success': True,
-            'data': {
-                'ranking': ranking,
-                'categoria': categoria.nome if categoria_id else 'Todas',
-                'total_projetos': len(ranking),
-                'timestamp': timezone.now().isoformat()
-            }
+            'ranking': list(ranking),
+            'categoria_id': categoria_id
         })
         
-    except CategoriaVotacao.DoesNotExist:
-        return JsonResponse({
-            'success': False,
-            'message': 'Categoria não encontrada.'
-        }, status=404)
-        
     except Exception as e:
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.error(f"Erro ao obter ranking: {str(e)}", exc_info=True)
-        
+        logger.error(f"Erro ranking: {e}")
         return JsonResponse({
             'success': False,
-            'message': 'Erro ao obter ranking.'
+            'message': 'Erro ao buscar ranking'
         }, status=500)