Descubrimiento de Tipos de Bloques

Endpoint Unificado de Tipos de Bloques

GET /api/tenant/{tenantId}/project/{projectId}/block/types/all

Descubre todos los tipos de bloques disponibles (filtros, calculadoras y enriquecimientos) en una sola llamada API. Este endpoint unificado es la forma recomendada de obtener información completa sobre todas las capacidades de análisis disponibles en mindzieStudio.

¿Por qué usar el endpoint unificado?

El endpoint unificado ofrece varias ventajas sobre consultar endpoints individuales por categoría:

• Solicitud única: Obtén todos los tipos de bloques en una sola llamada API en lugar de múltiples solicitudes
• Metadatos completos: Incluye enriquecimientos que no están disponibles a través de endpoints específicos de categoría
• Respuesta agrupada: Los resultados están organizados por categoría de bloque para facilitar su procesamiento
• Metadatos enriquecidos: Cada tipo de bloque incluye URLs de documentación, notas de uso y bloques relacionados
• Integración AI: Optimizado para asistentes de codificación AI e integración con el servidor MCP

Solicitud

GET /api/tenant/{tenantId}/project/{projectId}/block/types/all
Authorization: Bearer {token}

Parámetros de Ruta

Parámetro	Tipo	Requerido	Descripción
tenantId	GUID	Sí	Identificador del tenant
projectId	GUID	Sí	Identificador del proyecto

Respuesta

Estructura de la Respuesta

{
  "BlockTypes": [...],
  "Categories": ["Filtros de Atributos", "Filtros de Tiempo", "Calculadoras", ...],
  "TotalCount": 45,
  "ByBlockCategory": {
    "Filter": [...],
    "Calculator": [...],
    "Enrichment": [...]
  }
}

Campos de la Respuesta

Campo	Tipo	Descripción
BlockTypes	Array	Todos los tipos de bloques con metadatos completos
Categories	Array	Lista de todas las categorías únicas
TotalCount	Integer	Número total de tipos de bloques disponibles
ByBlockCategory	Object	Tipos de bloques agrupados por Filtro/Calculadora/Enriquecimiento

Objeto Tipo de Bloque

Cada tipo de bloque dentro del array BlockTypes contiene:

Campo	Tipo	Descripción
OperatorName	String	Identificador único para el tipo de bloque (por ejemplo, "CaseAttributeFilter")
DisplayName	String	Nombre legible mostrado en la interfaz
Description	String	Breve descripción de lo que hace el bloque
Category	String	Categoría funcional (por ejemplo, "Filtros de Atributos", "Filtros de Tiempo")
BlockType	String	Clasificación principal: "Filter", "Calculator" o "Enrichment"
DocumentationUrl	String	URL a la página de documentación para este tipo de bloque
UsageFrequency	String	Frecuencia de uso del bloque ("High", "Medium", "Low")
ExcludeFromOrFilter	Boolean	Indica si este filtro puede usarse en combinaciones OR
AutoTitleEnabled	Boolean	Indica si soporta generación automática de títulos
SupportedDisplayTypes	Array	Tipos de visualización soportados para los resultados
UsageNotes	String	Indicaciones adicionales para el uso de este tipo de bloque
RelatedBlocks	Array	Lista de tipos de bloques relacionados
CommonUseCases	Array	Escenarios típicos donde este tipo de bloque es útil

Ejemplo de Respuesta

{
  "BlockTypes": [
    {
      "OperatorName": "CaseAttributeFilter",
      "DisplayName": "Filtro de Atributo de Caso",
      "Description": "Filtra casos basados en valores de atributos como tipo de cliente, región o nivel de prioridad",
      "Category": "Filtros de Atributos",
      "BlockType": "Filter",
      "DocumentationUrl": "/mindzie_studio/filters/case-attribute-filter",
      "UsageFrequency": "High",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["table", "chart"],
      "UsageNotes": "Soporta coincidencia exacta, contiene y patrones regex",
      "RelatedBlocks": ["EventAttributeFilter", "CaseIdFilter"],
      "CommonUseCases": [
        "Filtrar por segmento de cliente",
        "Enfocarse en regiones específicas",
        "Analizar casos de alta prioridad"
      ]
    },
    {
      "OperatorName": "CaseDurationCalculator",
      "DisplayName": "Calculadora de Duración de Caso",
      "Description": "Calcula la duración total de los casos desde el inicio hasta el fin",
      "Category": "Calculadoras de Tiempo",
      "BlockType": "Calculator",
      "DocumentationUrl": "/mindzie_studio/calculators/case-duration-calculator",
      "UsageFrequency": "High",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["histogram", "table", "boxplot"],
      "UsageNotes": "La duración se calcula en la unidad de tiempo configurada en el proyecto",
      "RelatedBlocks": ["ActivityDurationCalculator", "WaitTimeCalculator"],
      "CommonUseCases": [
        "Analizar tiempos de ciclo de casos",
        "Identificar casos lentos",
        "Comparar eficiencia de procesos"
      ]
    },
    {
      "OperatorName": "CaseStageCalculator",
      "DisplayName": "Calculadora de Etapa de Caso",
      "Description": "Asigna etiquetas de etapa a los casos basadas en patrones de actividad y reglas",
      "Category": "Análisis de Etapas",
      "BlockType": "Enrichment",
      "DocumentationUrl": "/mindzie_studio/enrichments/case-stage-calculator",
      "UsageFrequency": "Medium",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["sankey", "table"],
      "UsageNotes": "Requiere que las definiciones de etapas estén configuradas",
      "RelatedBlocks": ["CaseStatusEnrichment", "MilestoneDetector"],
      "CommonUseCases": [
        "Rastrear progreso de casos a través de etapas",
        "Identificar etapas donde hay cuellos de botella",
        "Monitorear transiciones entre etapas"
      ]
    }
  ],
  "Categories": [
    "Filtros de Atributos",
    "Filtros de Tiempo",
    "Filtros de Actividad",
    "Calculadoras de Tiempo",
    "Calculadoras de Conteo",
    "Análisis de Etapas",
    "Enriquecimiento de Datos"
  ],
  "TotalCount": 45,
  "ByBlockCategory": {
    "Filter": [
      { "OperatorName": "CaseAttributeFilter", "DisplayName": "Filtro de Atributo de Caso", ... },
      { "OperatorName": "DateRangeFilter", "DisplayName": "Filtro por Rango de Fechas", ... }
    ],
    "Calculator": [
      { "OperatorName": "CaseDurationCalculator", "DisplayName": "Calculadora de Duración de Caso", ... }
    ],
    "Enrichment": [
      { "OperatorName": "CaseStageCalculator", "DisplayName": "Calculadora de Etapa de Caso", ... }
    ]
  }
}

Ejemplo en JavaScript

// Descubrir todos los tipos de bloques disponibles
async function discoverAllBlockTypes(tenantId, projectId, token) {
  const response = await fetch(
    `/api/tenant/${tenantId}/project/${projectId}/block/types/all`,
    {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    }
  );

  if (!response.ok) {
    throw new Error(`Error al descubrir tipos de bloques: ${response.status}`);
  }

  const data = await response.json();

  console.log(`Se descubrieron ${data.TotalCount} tipos de bloques:`);
  console.log(`- Filtros: ${data.ByBlockCategory.Filter.length}`);
  console.log(`- Calculadoras: ${data.ByBlockCategory.Calculator.length}`);
  console.log(`- Enriquecimientos: ${data.ByBlockCategory.Enrichment.length}`);

  return data;
}

// Encontrar tipos de bloques por categoría
function getBlockTypesByCategory(allTypes, category) {
  return allTypes.BlockTypes.filter(bt => bt.Category === category);
}

// Encontrar tipos de bloques de alto uso
function getHighUsageBlockTypes(allTypes) {
  return allTypes.BlockTypes.filter(bt => bt.UsageFrequency === 'High');
}

// Uso
const blockTypes = await discoverAllBlockTypes(tenantId, projectId, token);
const timeFilters = getBlockTypesByCategory(blockTypes, 'Filtros de Tiempo');
const popular = getHighUsageBlockTypes(blockTypes);

Ejemplo en Python

import requests
from typing import Dict, List, Any

class BlockTypeDiscovery:
    def __init__(self, base_url: str, tenant_id: str, project_id: str, token: str):
        self.base_url = base_url
        self.tenant_id = tenant_id
        self.project_id = project_id
        self.headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }

    def discover_all(self) -> Dict[str, Any]:
        """Descubrir todos los tipos de bloques disponibles"""
        url = f"{self.base_url}/api/tenant/{self.tenant_id}/project/{self.project_id}/block/types/all"
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def get_filters(self) -> List[Dict]:
        """Obtener todos los tipos de bloques filtro"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Filter', [])

    def get_calculators(self) -> List[Dict]:
        """Obtener todos los tipos de bloques calculadora"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Calculator', [])

    def get_enrichments(self) -> List[Dict]:
        """Obtener todos los tipos de bloques enriquecimiento"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Enrichment', [])

    def find_by_use_case(self, keyword: str) -> List[Dict]:
        """Encontrar tipos de bloques que coincidan con una palabra clave de caso de uso"""
        data = self.discover_all()
        results = []
        for block_type in data['BlockTypes']:
            use_cases = block_type.get('CommonUseCases', [])
            if any(keyword.lower() in uc.lower() for uc in use_cases):
                results.append(block_type)
        return results

# Uso
discovery = BlockTypeDiscovery(
    'https://your-mindzie-instance.com',
    'tenant-guid',
    'project-guid',
    'your-auth-token'
)

# Descubrir todos los tipos de bloques
all_types = discovery.discover_all()
print(f"Total de tipos de bloques: {all_types['TotalCount']}")

# Obtener tipos de bloques por categoría
filters = discovery.get_filters()
calculators = discovery.get_calculators()
enrichments = discovery.get_enrichments()

# Encontrar tipos de bloques para análisis de duración
duration_blocks = discovery.find_by_use_case('duration')

Endpoints Específicos por Categoría

El endpoint unificado es recomendado para la mayoría de casos. Sin embargo, los endpoints específicos por categoría siguen disponibles:

Endpoint	Descripción
GET /block/types?category=filters	Solo filtros
GET /block/types?category=calculators	Solo calculadoras
GET /block/types/{operatorName}	Detalles de un tipo de bloque específico
GET /block/types/{operatorName}/schema	Esquema de configuración para un tipo de bloque

Integración con el Servidor MCP

Los asistentes de codificación AI pueden usar el servidor MCP de mindzieAPI para descubrir tipos de bloques programáticamente:

mindzie_list_block_types category="unified"

Esta llamada a la herramienta MCP devuelve la misma respuesta unificada, facilitando que las herramientas AI comprendan todas las capacidades de análisis disponibles.

Consulta Integración con el Servidor MCP para la documentación completa.

Casos de Uso

Construcción de Interfaces Dinámicas

Usa el endpoint unificado para poblar menús de selección de tipo de bloque con información completa sobre cada opción.

Análisis Potenciado por AI

Los asistentes AI pueden descubrir las capacidades de análisis disponibles y sugerir tipos de bloques apropiados según los objetivos del usuario.

Generación de Documentación

Genera documentación dinámica iterando sobre todos los tipos de bloques y sus metadatos.

Auditoría de Capacidades

Enumera todas las capacidades de análisis disponibles para un proyecto para asegurar cobertura completa.