django-rule-engine 1.0.0__py3-none-any.whl

django_rule_engine/__init__.py

@@ -0,0 +1,5 @@
+"""Django rule-engine package."""
+
+default_app_config = 'django_rule_engine.apps.DjangoRuleEngineConfig'
+
+__version__ = '1.0.0'

django_rule_engine/api/__init__.py

@@ -0,0 +1,5 @@
+"""Base API module."""
+
+from .views import validate_rule
+
+__all__ = ['validate_rule']

django_rule_engine/api/urls.py

@@ -0,0 +1,8 @@
+"""API URLs for rule validation."""
+
+from django.urls import path
+from .views import validate_rule
+
+urlpatterns = [
+    path('validate-rule/', validate_rule, name='validate_rule'),
+]

django_rule_engine/api/views.py

@@ -0,0 +1,85 @@
+"""API views for rule validation."""
+
+import json
+from django.http import JsonResponse
+from django.views.decorators.http import require_http_methods
+from django.views.decorators.csrf import ensure_csrf_cookie
+import rule_engine
+
+
+@require_http_methods(["POST"])
+@ensure_csrf_cookie
+def validate_rule(request):
+    """
+    Valida uma regra do rule-engine com dados de exemplo.
+    
+    POST /api/validate-rule/
+    Body: {
+        "rule": "age >= 18 and status == 'active'",
+        "data": {"age": 25, "status": "active"}
+    }
+    
+    Response: {
+        "valid": true,
+        "result": true,
+        "matches": true
+    }
+    
+    Ou em caso de erro:
+    {
+        "valid": false,
+        "error": "mensagem de erro"
+    }
+    """
+    print(f"DEBUG: validate_rule chamado - Method: {request.method}")
+    print(f"DEBUG: Path: {request.path}")
+    print(f"DEBUG: Body: {request.body}")
+    
+    try:
+        # Parse request body
+        body = json.loads(request.body)
+        rule_text = body.get('rule', '')
+        data = body.get('data', {})
+        
+        if not rule_text:
+            return JsonResponse({
+                'valid': False,
+                'error': 'Regra não pode ser vazia'
+            }, status=400)
+        
+        # Compila a regra
+        try:
+            rule = rule_engine.Rule(rule_text)
+        except Exception as e:
+            return JsonResponse({
+                'valid': False,
+                'error': f'Erro ao compilar regra: {str(e)}'
+            }, status=400)
+        
+        # Avalia a regra com os dados fornecidos
+        try:
+            result = rule.matches(data)
+            
+            return JsonResponse({
+                'valid': True,
+                'result': result,
+                'matches': result,
+                'rule': rule_text,
+                'data': data
+            })
+        except Exception as e:
+            return JsonResponse({
+                'valid': False,
+                'error': f'Erro ao avaliar regra: {str(e)}'
+            }, status=400)
+    
+    except json.JSONDecodeError as e:
+        return JsonResponse({
+            'valid': False,
+            'error': f'JSON inválido: {str(e)}'
+        }, status=400)
+    except Exception as e:
+        return JsonResponse({
+            'valid': False,
+            'error': f'Erro interno: {str(e)}'
+        }, status=500)

django_rule_engine/apps.py

@@ -0,0 +1,11 @@
+"""Django app configuration for django_rule_engine."""
+
+from django.apps import AppConfig
+
+
+class DjangoRuleEngineConfig(AppConfig):
+    """Configuration for Django rule-engine app."""
+    
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_rule_engine'
+    verbose_name = 'Django Rule Engine'

django_rule_engine/fields/__init__.py

@@ -0,0 +1,6 @@
+"""Custom Django fields for the application."""
+
+from .rule_field import RuleField
+from .rule_widget import RuleWidget
+
+__all__ = ["RuleField", "RuleWidget"]

django_rule_engine/fields/rule_field.py

@@ -0,0 +1,89 @@
+"""Django field for rule-engine rules."""
+
+import json
+from django.db import models
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+import rule_engine
+
+from .rule_widget import RuleWidget
+
+
+class RuleField(models.TextField):
+    """
+    Campo Django para armazenar e validar regras do rule-engine.
+    
+    Args:
+        example_data: Dicionário ou string JSON com dados de exemplo para validação.
+                     Pode ser sobrescrito pelo usuário no admin.
+        resolver: Opcional. Resolver customizado para rule-engine.
+        **kwargs: Argumentos adicionais do TextField.
+    
+    Example:
+        class MyModel(models.Model):
+            rule = RuleField(
+                verbose_name="Regra de validação",
+                example_data={"age": 25, "status": "active"},
+                help_text="Digite uma regra válida do rule-engine"
+            )
+    """
+    
+    description = _("Campo para regras do rule-engine")
+    
+    def __init__(self, *args, example_data=None, resolver=None, **kwargs):
+        self.example_data = example_data
+        self.resolver = resolver
+        super().__init__(*args, **kwargs)
+    
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.example_data is not None:
+            kwargs['example_data'] = self.example_data
+        if self.resolver is not None:
+            kwargs['resolver'] = self.resolver
+        return name, path, args, kwargs
+    
+    def formfield(self, **kwargs):
+        """Retorna o formfield com o widget customizado."""
+        # Prepara example_data para o widget
+        example_data_json = None
+        if self.example_data is not None:
+            if isinstance(self.example_data, str):
+                example_data_json = self.example_data
+            else:
+                example_data_json = json.dumps(self.example_data, indent=2)
+        
+        # Define o widget como padrão
+        kwargs['widget'] = RuleWidget(example_data=example_data_json)
+        
+        return super().formfield(**kwargs)
+    
+    def validate(self, value, model_instance):
+        """Valida se a regra é válida."""
+        super().validate(value, model_instance)
+        
+        if not value:
+            return
+        
+        try:
+            # Tenta compilar a regra
+            # O resolver deve ser passado no contexto, não no init do Rule
+            rule_engine.Rule(value)
+        except Exception as e:
+            raise ValidationError(
+                _('Regra inválida: %(error)s'),
+                code='invalid_rule',
+                params={'error': str(e)},
+            )
+    
+    def to_python(self, value):
+        """Converte o valor do banco para Python."""
+        if value is None:
+            return value
+        return str(value)
+    
+    def get_prep_value(self, value):
+        """Prepara o valor para salvar no banco."""
+        if value is None:
+            return value
+        return str(value)

django_rule_engine/fields/rule_widget.py

@@ -0,0 +1,85 @@
+"""Widget Django para edição de regras do rule-engine."""
+
+import json
+from django import forms
+from django.utils.safestring import mark_safe
+from django.conf import settings
+from django_json_widget.widgets import JSONEditorWidget
+
+
+class RuleWidget(forms.Textarea):
+    """
+    Widget customizado para editar regras do rule-engine.
+    
+    Fornece:
+    - Editor de código com syntax highlighting (CodeMirror)
+    - Campo para JSON de exemplo (editável pelo usuário)
+    - Validação dinâmica no frontend
+    - Feedback visual do resultado da regra
+    """
+    
+    template_name = 'widgets/rule_widget.html'
+    
+    class Media:
+        css = {
+            'all': (
+                'https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.16/codemirror.min.css',
+                'https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.16/theme/material.min.css',
+                'rule_widget/rule_widget.css',
+                'rule_widget/rule_widget_highlighting.css',  # Estilos customizados de highlighting
+            )
+        }
+        js = (
+            'https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.16/codemirror.min.js',
+            'rule_widget/codemirror-rule-engine.js',  # Modo customizado para rule-engine
+            'rule_widget/rule_widget.js',
+        )
+    
+    def __init__(self, example_data=None, attrs=None):
+        """
+        Inicializa o widget.
+        
+        Args:
+            example_data: JSON string com dados de exemplo
+            attrs: Atributos HTML adicionais
+        """
+        self.example_data = example_data or '{}'
+        super().__init__(attrs)
+    
+    def get_context(self, name, value, attrs):
+        """Adiciona contexto extra para o template."""
+        context = super().get_context(name, value, attrs)
+        
+        # Formata o example_data para exibição
+        try:
+            if isinstance(self.example_data, str):
+                example_obj = json.loads(self.example_data)
+            else:
+                example_obj = self.example_data
+            formatted_example = json.dumps(example_obj, indent=2)
+        except (json.JSONDecodeError, TypeError):
+            formatted_example = self.example_data
+        
+        # Cria um JSONEditorWidget para o campo de exemplo
+        json_widget = JSONEditorWidget(height='120px')  # ~5 linhas
+        json_widget_name = f"{name}_example_data"
+        json_widget_attrs = {
+            'id': f"{attrs.get('id', name)}_example_data",
+            'class': 'example-data-json-editor',
+        }
+        json_widget_html = json_widget.render(json_widget_name, formatted_example, json_widget_attrs)
+        
+        context['widget'].update({
+            'example_data': formatted_example,
+            'field_id': attrs.get('id', name),
+            'json_widget_html': mark_safe(json_widget_html),
+            'json_widget_media': json_widget.media,
+        })
+        
+        return context
+    
+    def format_value(self, value):
+        """Formata o valor para exibição no widget."""
+        if value is None:
+            return ''
+        return str(value)

django_rule_engine/fields/test_rule_field.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python
+"""
+Script de teste do RuleField.
+
+Execute com:
+    python manage.py shell < base/fields/test_rule_field.py
+
+Ou no shell do Django:
+    from django_rule_engine.fields.test_rule_field import test_all
+    test_all()
+"""
+
+import json
+
+
+def test_rule_compilation():
+    """Testa compilação básica de regras."""
+    import rule_engine
+    
+    print("=" * 60)
+    print("TESTE 1: Compilação de Regras")
+    print("=" * 60)
+    
+    regras = [
+        "age >= 18",
+        'status == "active"',
+        "age >= 18 and status == 'active'",
+        '(price > 100 or quantity >= 5) and customer_type == "premium"',
+        '"@ifrn.edu.br" in email',
+        "len(name) > 3",
+    ]
+    
+    for regra in regras:
+        try:
+            rule = rule_engine.Rule(regra)
+            print(f"✓ OK: {regra}")
+        except Exception as e:
+            print(f"✗ ERRO: {regra}")
+            print(f"  Mensagem: {e}")
+    
+    print()
+
+
+def test_rule_evaluation():
+    """Testa avaliação de regras com dados."""
+    import rule_engine
+    
+    print("=" * 60)
+    print("TESTE 2: Avaliação de Regras")
+    print("=" * 60)
+    
+    casos = [
+        {
+            "regra": "age >= 18",
+            "dados": {"age": 25},
+            "esperado": True
+        },
+        {
+            "regra": "age >= 18",
+            "dados": {"age": 15},
+            "esperado": False
+        },
+        {
+            "regra": 'status == "active"',
+            "dados": {"status": "active"},
+            "esperado": True
+        },
+        {
+            "regra": 'age >= 18 and status == "active"',
+            "dados": {"age": 25, "status": "active"},
+            "esperado": True
+        },
+        {
+            "regra": 'age >= 18 and status == "active"',
+            "dados": {"age": 15, "status": "active"},
+            "esperado": False
+        },
+        {
+            "regra": '"@ifrn.edu.br" in email',
+            "dados": {"email": "usuario@ifrn.edu.br"},
+            "esperado": True
+        },
+        {
+            "regra": "len(name) > 3",
+            "dados": {"name": "João Silva"},
+            "esperado": True
+        },
+        {
+            "regra": "(price * quantity) > 1000",
+            "dados": {"price": 100, "quantity": 12},
+            "esperado": True
+        },
+    ]
+    
+    for i, caso in enumerate(casos, 1):
+        regra = rule_engine.Rule(caso["regra"])
+        resultado = regra.matches(caso["dados"])
+        
+        status = "✓" if resultado == caso["esperado"] else "✗"
+        print(f"{status} Caso {i}:")
+        print(f"  Regra: {caso['regra']}")
+        print(f"  Dados: {caso['dados']}")
+        print(f"  Resultado: {resultado} (esperado: {caso['esperado']})")
+        print()
+
+
+def test_field_validation():
+    """Testa validação do campo Django."""
+    from django_rule_engine.fields import RuleField
+    from django.core.exceptions import ValidationError
+    
+    print("=" * 60)
+    print("TESTE 3: Validação do Campo Django")
+    print("=" * 60)
+    
+    field = RuleField()
+    
+    # Regras válidas
+    regras_validas = [
+        "age >= 18",
+        'status == "active"',
+        "age >= 18 and status == 'active'",
+    ]
+    
+    print("Testando regras VÁLIDAS:")
+    for regra in regras_validas:
+        try:
+            field.validate(regra, None)
+            print(f"✓ OK: {regra}")
+        except ValidationError as e:
+            print(f"✗ ERRO (inesperado): {regra}")
+            print(f"  Mensagem: {e}")
+    
+    print()
+    
+    # Regras inválidas
+    regras_invalidas = [
+        "age >>= 18",  # Operador inválido
+        "age == ",  # Incompleta
+        "status = 'active'",  # Usa = ao invés de ==
+    ]
+    
+    print("Testando regras INVÁLIDAS:")
+    for regra in regras_invalidas:
+        try:
+            field.validate(regra, None)
+            print(f"✗ ERRO (deveria falhar): {regra}")
+        except ValidationError as e:
+            print(f"✓ OK (erro esperado): {regra}")
+            print(f"  Mensagem: {e}")
+    
+    print()
+
+
+def test_api_simulation():
+    """Simula chamada à API de validação."""
+    import rule_engine
+    
+    print("=" * 60)
+    print("TESTE 4: Simulação da API")
+    print("=" * 60)
+    
+    request_body = {
+        "rule": "age >= 18 and status == 'active'",
+        "data": {
+            "age": 25,
+            "status": "active"
+        }
+    }
+    
+    print(f"Request Body:")
+    print(json.dumps(request_body, indent=2))
+    print()
+    
+    try:
+        rule = rule_engine.Rule(request_body["rule"])
+        result = rule.matches(request_body["data"])
+        
+        response = {
+            "valid": True,
+            "result": result,
+            "matches": result,
+            "rule": request_body["rule"],
+            "data": request_body["data"]
+        }
+        
+        print("Response:")
+        print(json.dumps(response, indent=2))
+        print()
+        print("✓ API simulada com sucesso!")
+    
+    except Exception as e:
+        response = {
+            "valid": False,
+            "error": str(e)
+        }
+        print("Response (ERRO):")
+        print(json.dumps(response, indent=2))
+        print()
+        print("✗ Erro na simulação da API")
+    
+    print()
+
+
+def test_real_world_examples():
+    """Testa exemplos do mundo real."""
+    import rule_engine
+    
+    print("=" * 60)
+    print("TESTE 5: Exemplos do Mundo Real")
+    print("=" * 60)
+    
+    exemplos = [
+        {
+            "nome": "Validação de Matrícula",
+            "regra": 'idade >= 16 and nivel_ensino == "medio" and aprovado == true',
+            "dados": {
+                "idade": 18,
+                "nivel_ensino": "medio",
+                "aprovado": True
+            },
+            "esperado": True
+        },
+        {
+            "nome": "Desconto para Cliente Premium",
+            "regra": '(quantidade >= 10 or valor_total > 1000) and tipo_cliente == "premium"',
+            "dados": {
+                "quantidade": 12,
+                "valor_total": 500,
+                "tipo_cliente": "premium"
+            },
+            "esperado": True
+        },
+        {
+            "nome": "Email Institucional",
+            "regra": '"@ifrn.edu.br" in email and ativo == true',
+            "dados": {
+                "email": "joao.silva@ifrn.edu.br",
+                "ativo": True
+            },
+            "esperado": True
+        },
+        {
+            "nome": "Acesso de Administrador",
+            "regra": 'is_admin == true or (departamento == "TI" and nivel_acesso >= 5)',
+            "dados": {
+                "is_admin": False,
+                "departamento": "TI",
+                "nivel_acesso": 7
+            },
+            "esperado": True
+        },
+    ]
+    
+    for exemplo in exemplos:
+        print(f"\n{exemplo['nome']}:")
+        print(f"  Regra: {exemplo['regra']}")
+        print(f"  Dados: {json.dumps(exemplo['dados'], indent=4)}")
+        
+        try:
+            rule = rule_engine.Rule(exemplo["regra"])
+            resultado = rule.matches(exemplo["dados"])
+            
+            status = "✓" if resultado == exemplo["esperado"] else "✗"
+            print(f"  {status} Resultado: {resultado} (esperado: {exemplo['esperado']})")
+        
+        except Exception as e:
+            print(f"  ✗ ERRO: {e}")
+    
+    print()
+
+
+def test_all():
+    """Executa todos os testes."""
+    print("\n" + "=" * 60)
+    print("INICIANDO TESTES DO RULEFIELD")
+    print("=" * 60 + "\n")
+    
+    try:
+        test_rule_compilation()
+        test_rule_evaluation()
+        test_field_validation()
+        test_api_simulation()
+        test_real_world_examples()
+        
+        print("=" * 60)
+        print("TODOS OS TESTES CONCLUÍDOS!")
+        print("=" * 60)
+        
+    except Exception as e:
+        print(f"\n✗ ERRO DURANTE OS TESTES: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    test_all()