Obter Regra

curl --request GET \
  --url http://api.gu1.ai/rules/{id} \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('http://api.gu1.ai/rules/{id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "http://api.gu1.ai/rules/{id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "http://api.gu1.ai/rules/{id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("http://api.gu1.ai/rules/{id}")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "organizationId": "<string>",
  "name": "<string>",
  "description": "<string>",
  "category": "<string>",
  "status": "<string>",
  "enabled": true,
  "priority": 123,
  "score": 123,
  "conditions": {},
  "conditionCode": "<string>",
  "actions": [
    {}
  ],
  "scope": {},
  "targetEntityTypes": [
    {}
  ],
  "evaluationMode": "<string>",
  "riskMatrixId": "<string>",
  "version": 123,
  "previousVersionId": "<string>",
  "tags": [
    {}
  ],
  "stats": {},
  "createdBy": "<string>",
  "createdAt": "<string>",
  "updatedBy": "<string>",
  "updatedAt": "<string>"
}

GET

rules

{id}

Obter Regra

curl --request GET \
  --url http://api.gu1.ai/rules/{id} \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('http://api.gu1.ai/rules/{id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "http://api.gu1.ai/rules/{id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "http://api.gu1.ai/rules/{id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("http://api.gu1.ai/rules/{id}")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "organizationId": "<string>",
  "name": "<string>",
  "description": "<string>",
  "category": "<string>",
  "status": "<string>",
  "enabled": true,
  "priority": 123,
  "score": 123,
  "conditions": {},
  "conditionCode": "<string>",
  "actions": [
    {}
  ],
  "scope": {},
  "targetEntityTypes": [
    {}
  ],
  "evaluationMode": "<string>",
  "riskMatrixId": "<string>",
  "version": 123,
  "previousVersionId": "<string>",
  "tags": [
    {}
  ],
  "stats": {},
  "createdBy": "<string>",
  "createdAt": "<string>",
  "updatedBy": "<string>",
  "updatedAt": "<string>"
}

Visão Geral

Recupera informações completas sobre uma regra específica, incluindo suas condições, ações, estatísticas de execução e histórico de versões.

Endpoint

GET http://api.gu1.ai/rules/{id}

Autenticação

Requer uma chave API válida no cabeçalho de Authorization:

Authorization: Bearer YOUR_API_KEY

Parâmetros de Rota

string

required

UUID da regra a recuperar

Resposta

string

UUID da regra

string

ID da sua organização

string

Nome da regra

string

Descrição da regra

string

Categoria da regra (kyc, kyb, aml, fraud, compliance, custom)

string

Status atual (draft, active, shadow, archived, inactive)

boolean

Se a regra está habilitada

number

Prioridade da regra (1-100)

number

Pontuação de risco atribuída quando a regra corresponde

object

Estrutura de condições completa com lógica aninhada

string

Representação em string JSON das condições (para armazenamento)

array

Array de ações a executar quando a regra corresponde

object

Configuração de escopo da regra (países, tipos de entidade, janelas temporais)

array

Array de tipos de entidade aos quais a regra se aplica

string

Modo de avaliação (sync ou async)

string

UUID da matriz de risco associada (se houver)

number

Número da versão atual

string

UUID da versão anterior (se houver)

array

Array de tags para organização

object

Estatísticas de execução (execuções, sucessos, falhas)

string

ID do usuário que criou a regra

string

Timestamp ISO de criação

string

ID do usuário que atualizou a regra por último

string

Timestamp ISO da última atualização

Exemplos de Requisições

curl -X GET http://api.gu1.ai/rules/e2cdd639-52cc-4749-9b16-927bfa5dfaea \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch(
  'http://api.gu1.ai/rules/e2cdd639-52cc-4749-9b16-927bfa5dfaea',
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

const rule = await response.json();
console.log('Regra:', rule.name);
console.log('Status:', rule.status);
console.log('Execuções:', rule.stats.executions);

import requests

response = requests.get(
    'http://api.gu1.ai/rules/e2cdd639-52cc-4749-9b16-927bfa5dfaea',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY'
    }
)

rule = response.json()
print(f"Regra: {rule['name']}")
print(f"Status: {rule['status']}")
print(f"Execuções: {rule['stats']['executions']}")

Exemplo de Resposta

{
  "id": "e2cdd639-52cc-4749-9b16-927bfa5dfaea",
  "organizationId": "71e8f908-e032-4fcb-b0ce-ad0cd0ffb236",
  "name": "CNPJ Blocklist Check",
  "description": "Block companies with specific CNPJ",
  "category": "kyb",
  "status": "active",
  "enabled": true,
  "priority": 100,
  "score": 85,
  "conditions": {
    "operator": "AND",
    "conditions": [
      {
        "id": "cond-1766412627987-0",
        "type": "simple",
        "field": "enrichmentData.normalized.taxId",
        "value": "33.592.510/0001-54",
        "filters": [],
        "operator": "eq",
        "countryMetadata": {
          "reason": "Selected from BR enrichment fields",
          "confidence": 100,
          "countryCode": "BR",
          "manuallySet": true,
          "autoDetected": false
        }
      }
    ]
  },
  "conditionCode": "{\"operator\":\"AND\",\"conditions\":[{\"field\":\"enrichmentData.normalized.taxId\",\"operator\":\"eq\",\"value\":\"33.592.510/0001-54\",\"countryMetadata\":{\"countryCode\":\"BR\",\"autoDetected\":false,\"manuallySet\":true,\"confidence\":100,\"reason\":\"Selected from BR enrichment fields\"},\"filters\":[],\"id\":\"cond-1766412627987-0\",\"type\":\"simple\"}]}",
  "actions": [
    {
      "tags": ["blocklist", "high-priority"],
      "type": "createAlert",
      "createAlert": {
        "type": "COMPLIANCE",
        "title": "Blocklisted Company Detected",
        "severity": "CRITICAL",
        "recipients": ["compliance@company.com"],
        "description": "Company CNPJ found in blocklist"
      }
    },
    {
      "tags": [],
      "type": "updateEntityStatus",
      "updateEntityStatus": {
        "status": "blocked",
        "reason": "CNPJ in blocklist"
      }
    }
  ],
  "scope": {
    "type": "entity",
    "countries": ["BR"],
    "entityTypes": ["company"],
    "temporalWindow": {
      "days": 30,
      "hours": 24
    }
  },
  "targetEntityTypes": ["company"],
  "evaluationMode": "sync",
  "riskMatrixId": "d257247b-af7b-402a-ad8f-eac209e2990e",
  "version": 1,
  "previousVersionId": null,
  "abTest": null,
  "schedule": null,
  "tags": [],
  "createdBy": "f35c10cb-9b67-4cda-9aea-f36567375dba",
  "createdAt": "2024-12-22T14:10:28.131Z",
  "updatedBy": "f35c10cb-9b67-4cda-9aea-f36567375dba",
  "updatedAt": "2024-12-22T14:44:29.627Z",
  "stats": {
    "failures": 0,
    "successes": 7,
    "executions": 7
  }
}

Respostas de Erro

404 Not Found

{
  "error": "Rule not found",
  "id": "e2cdd639-52cc-4749-9b16-927bfa5dfaea"
}

401 Unauthorized

{
  "error": "Invalid or missing API key"
}

403 Forbidden

{
  "error": "Access denied",
  "message": "You don't have permission to view this rule"
}

Casos de Uso

Exibir Detalhes da Regra na UI

async function loadRuleDetails(ruleId) {
  const response = await fetch(
    `http://api.gu1.ai/rules/${ruleId}`,
    {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  const rule = await response.json();

  return {
    id: rule.id,
    name: rule.name,
    description: rule.description,
    status: rule.status,
    enabled: rule.enabled,
    priority: rule.priority,
    score: rule.score,
    category: rule.category,
    lastUpdated: new Date(rule.updatedAt),
    performance: {
      executions: rule.stats.executions,
      successRate: (rule.stats.successes / rule.stats.executions * 100).toFixed(1) + '%',
      failureRate: (rule.stats.failures / rule.stats.executions * 100).toFixed(1) + '%'
    },
    conditions: rule.conditions,
    actions: rule.actions.map(a => ({
      type: a.type,
      details: a[a.type]
    }))
  };
}

Monitorar Desempenho da Regra

def monitor_rule_performance(rule_id):
    """Monitorar estatísticas de execução da regra"""
    response = requests.get(
        f'http://api.gu1.ai/rules/{rule_id}',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY'
        }
    )

    rule = response.json()
    stats = rule['stats']

    total = stats['executions']
    if total == 0:
        print(f"Regra '{rule['name']}' ainda não foi executada")
        return

    success_rate = (stats['successes'] / total) * 100
    failure_rate = (stats['failures'] / total) * 100

    print(f"Regra: {rule['name']}")
    print(f"Status: {rule['status']}")
    print(f"Habilitada: {rule['enabled']}")
    print(f"\nDesempenho:")
    print(f"  Total de Execuções: {total}")
    print(f"  Taxa de Sucesso: {success_rate:.1f}%")
    print(f"  Taxa de Falha: {failure_rate:.1f}%")
    print(f"\nÚltima Atualização: {rule['updatedAt']}")

    # Alertar se taxa de falha for alta
    if failure_rate > 10:
        print(f"\nAVISO: Taxa de falha alta detectada!")

    return rule

Clonar Configuração da Regra

async function cloneRule(sourceRuleId, newName) {
  // Obter a regra de origem
  const response = await fetch(
    `http://api.gu1.ai/rules/${sourceRuleId}`,
    {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  const sourceRule = await response.json();

  // Criar nova regra com nome modificado
  const newRule = {
    name: newName,
    description: `Clonada de: ${sourceRule.name}`,
    category: sourceRule.category,
    targetEntityTypes: sourceRule.targetEntityTypes,
    conditions: sourceRule.conditions,
    actions: sourceRule.actions,
    enabled: false, // Iniciar desabilitada
    priority: sourceRule.priority,
    score: sourceRule.score,
    status: 'draft', // Iniciar como rascunho
    evaluationMode: sourceRule.evaluationMode,
    scope: sourceRule.scope,
    tags: [...sourceRule.tags, 'cloned']
  };

  // Criar a regra clonada
  const createResponse = await fetch(
    'http://api.gu1.ai/rules',
    {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(newRule)
    }
  );

  const clonedRule = await createResponse.json();
  console.log('Regra clonada com sucesso:', clonedRule.id);

  return clonedRule;
}

Exportar Configuração da Regra

import json

def export_rule_config(rule_id, output_file):
    """Exportar configuração da regra para arquivo JSON"""
    response = requests.get(
        f'http://api.gu1.ai/rules/{rule_id}',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY'
        }
    )

    rule = response.json()

    # Remover campos de runtime
    export_data = {
        'name': rule['name'],
        'description': rule['description'],
        'category': rule['category'],
        'targetEntityTypes': rule['targetEntityTypes'],
        'conditions': rule['conditions'],
        'actions': rule['actions'],
        'priority': rule['priority'],
        'score': rule['score'],
        'evaluationMode': rule['evaluationMode'],
        'scope': rule.get('scope'),
        'tags': rule.get('tags', [])
    }

    # Escrever no arquivo
    with open(output_file, 'w') as f:
        json.dump(export_data, f, indent=2)

    print(f"Configuração da regra exportada para {output_file}")
    return export_data

Melhores Práticas

Cache de Dados da Regra: Fazer cache de regras acessadas frequentemente para reduzir chamadas API
Monitorar Estatísticas: Revisar regularmente o objeto stats para insights de desempenho
Rastrear Versões: Usar version e previousVersionId para trilhas de auditoria
Verificar Status: Sempre verificar enabled e status antes da execução
Usar Tags: Aproveitar tags para organização e filtragem

Veja Também

Listar Regras - Consultar e filtrar regras
Atualizar Regra - Modificar configuração da regra
Executar Regra - Testar regra contra entidades
Criar Regra - Criar novas regras

Criar Regra Listar Regras

⌘I

​Visão Geral

​Endpoint

​Autenticação

​Parâmetros de Rota

​Resposta

​Exemplos de Requisições

​Exemplo de Resposta

​Respostas de Erro

​404 Not Found

​401 Unauthorized

​403 Forbidden

​Casos de Uso

​Exibir Detalhes da Regra na UI

​Monitorar Desempenho da Regra

​Clonar Configuração da Regra

​Exportar Configuração da Regra

​Melhores Práticas

​Veja Também

Visão Geral

Endpoint

Autenticação

Parâmetros de Rota

Resposta

Exemplos de Requisições

Exemplo de Resposta

Respostas de Erro

404 Not Found

401 Unauthorized

403 Forbidden

Casos de Uso

Exibir Detalhes da Regra na UI

Monitorar Desempenho da Regra

Clonar Configuração da Regra

Exportar Configuração da Regra

Melhores Práticas

Veja Também