Tipos de Bloques

Categorías de Bloques de Análisis

Explore diferentes tipos de bloques incluyendo filtros, calculadoras y configuraciones de alertas. Conozca las capacidades de cada tipo, opciones de configuración y puntos de creación.

Bloques de Filtro

POST /api/{tenantId}/{projectId}/block/filter

Los bloques de filtro aplican criterios de filtrado de datos a conjuntos de datos, reduciendo los datos mediante condiciones como rangos de fechas, filtros de valores o expresiones lógicas. Son la base para un análisis enfocado en subconjuntos de datos específicos.

Capacidades

Filtrado por Rango de Fechas: Filtrar datos dentro de periodos de tiempo específicos
Filtrado por Actividad: Incluir o excluir actividades de proceso específicas
Filtrado por Atributo de Caso: Filtrar basado en propiedades y metadatos del caso
Filtrado por Rango de Valores: Aplicar condiciones numéricas y de texto
Lógica Compleja: Combinar múltiples filtros con operaciones AND/OR

Cuerpo de la Solicitud

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Filtro por Rango de Fechas",
  "blockDescription": "Filtra datos de proceso para los últimos 30 días"
}

Ejemplos de Configuración

// Configuración de filtro por rango de fechas
{
  "filterType": "dateRange",
  "startDate": "2024-01-01T00:00:00Z",
  "endDate": "2024-01-31T23:59:59Z",
  "dateField": "timestamp"
}

// Configuración de filtro por actividad
{
  "filterType": "activity",
  "include": ["Order Created", "Payment Processed"],
  "exclude": ["System Log"]
}

// Configuración de filtro por atributo de caso
{
  "filterType": "caseAttribute",
  "attribute": "customerType",
  "operator": "equals",
  "value": "Premium"
}

Bloques de Calculadora

POST /api/{tenantId}/{projectId}/block/calculator

Los bloques de calculadora realizan operaciones matemáticas y cálculos analíticos sobre conjuntos de datos. Calculan métricas, agregaciones, medidas estadísticas y valores derivados para el análisis de minería de procesos.

Capacidades

Cálculos de Duración: Tiempos de ciclo y tiempos de entrega de procesos
Análisis de Frecuencia: Tasas y patrones de ocurrencia de actividades
Métricas de Rendimiento: Rendimiento, eficiencia y utilización
Análisis Estadístico: Media, mediana, percentiles y distribuciones
Fórmulas Personalizadas: Expresiones matemáticas complejas y KPIs

Cuerpo de la Solicitud

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Calculadora de Duración de Proceso",
  "blockDescription": "Calcula la duración promedio del caso y tiempos de ciclo"
}

Ejemplos de Configuración

// Configuración de cálculo de duración
{
  "calculationType": "duration",
  "startActivity": "Order Created",
  "endActivity": "Order Completed",
  "unit": "hours",
  "aggregation": "average"
}

// Configuración de cálculo de frecuencia
{
  "calculationType": "frequency",
  "groupBy": "activity",
  "timeWindow": "daily",
  "metric": "count"
}

// Configuración personalizada de cálculo KPI
{
  "calculationType": "custom",
  "formula": "(completedCases / totalCases) * 100",
  "resultUnit": "percentage",
  "name": "Tasa de Finalización"
}

Bloques de Alerta

POST /api/{tenantId}/{projectId}/block/alert

Los bloques de alerta monitorean condiciones de datos y disparan notificaciones cuando se cumplen criterios específicos. Proporcionan monitoreo automatizado y detección de excepciones para flujos de minería de procesos y requisitos de cumplimiento.

Capacidades

Monitoreo de Umbrales: Alertar cuando las métricas exceden límites definidos
Detección de Patrones: Identificar patrones inusuales en el comportamiento del proceso
Monitoreo de Cumplimiento: Rastrear el cumplimiento de reglas de negocio
Alertas de Rendimiento: Monitorear violaciones de SLA y degradación del rendimiento
Notificaciones en Tiempo Real: Alertas inmediatas para condiciones críticas

Cuerpo de la Solicitud

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Alerta de Violación de SLA",
  "blockDescription": "Alertas cuando la duración del caso excede el umbral de SLA"
}

Ejemplos de Configuración

// Configuración de alerta por umbral
{
  "alertType": "threshold",
  "metric": "caseDuration",
  "operator": "greaterThan",
  "threshold": 48,
  "unit": "hours",
  "severity": "high"
}

// Configuración de alerta por desviación de patrón
{
  "alertType": "patternDeviation",
  "baselinePattern": "Order -> Payment -> Fulfillment",
  "deviationTolerance": 0.1,
  "minOccurrences": 10
}

// Configuración de alerta de cumplimiento
{
  "alertType": "compliance",
  "rule": "approvalRequired",
  "condition": "amount > 1000",
  "requiredActivity": "Manager Approval"
}

Comparación de Tipos de Bloques

Elija el tipo de bloque adecuado para sus necesidades de análisis:

Tipo de Bloque	Propósito Principal	Entrada	Salida	Casos de Uso
Filtro	Reducción y enfoque de datos	Conjunto de datos completo	Conjunto filtrado	Análisis por periodo de tiempo, caminos específicos del proceso
Calculadora	Cálculo de métricas y KPIs	Conjunto de datos (filtrado o completo)	Valores/métricas calculadas	Medición de rendimiento, análisis estadístico
Alerta	Monitoreo y notificaciones	Métricas o conjunto de datos	Condiciones de alerta/notificaciones	Monitoreo de SLA, detección de excepciones

Ejemplo: Flujo Completo de Bloques

Este ejemplo demuestra la creación de diferentes tipos de bloques para un análisis integral:

// Crear un bloque de filtro para enfocar en datos recientes
const createDateFilter = async (notebookId) => {
  const response = await fetch(`/api/${tenantId}/${projectId}/block/filter`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      notebookId: notebookId,
      blockTitle: 'Filtro Últimos 30 Días',
      blockDescription: 'Enfocar análisis en datos recientes del proceso'
    })
  });
  return await response.json();
};

// Crear un bloque de calculadora para computar métricas
const createDurationCalculator = async (notebookId) => {
  const response = await fetch(`/api/${tenantId}/${projectId}/block/calculator`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      notebookId: notebookId,
      blockTitle: 'Calculadora de Duración Promedio',
      blockDescription: 'Calcular el tiempo promedio de procesamiento de casos'
    })
  });
  return await response.json();
};

// Crear un bloque de alerta para monitoreo
const createSLAAlert = async (notebookId) => {
  const response = await fetch(`/api/${tenantId}/${projectId}/block/alert`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      notebookId: notebookId,
      blockTitle: 'Alerta de Violación de SLA',
      blockDescription: 'Monitorear incumplimientos de SLA'
    })
  });
  return await response.json();
};

// Construir flujo completo de análisis
const buildAnalysisWorkflow = async (notebookId) => {
  try {
    // 1. Filtrar datos al periodo reciente
    const filterBlock = await createDateFilter(notebookId);
    console.log('Bloque de filtro creado:', filterBlock.blockId);

    // 2. Calcular métricas de rendimiento
    const calculatorBlock = await createDurationCalculator(notebookId);
    console.log('Bloque calculadora creado:', calculatorBlock.blockId);

    // 3. Configurar alertas de monitoreo
    const alertBlock = await createSLAAlert(notebookId);
    console.log('Bloque de alerta creado:', alertBlock.blockId);

    return {
      filter: filterBlock,
      calculator: calculatorBlock,
      alert: alertBlock
    };
  } catch (error) {
    console.error('Error al construir el flujo de trabajo:', error);
    throw error;
  }
};

Implementación en Python

import requests
from typing import Dict, Any

class BlockTypeManager:
    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 create_filter_block(self, notebook_id: str, title: str, description: str) -> Dict[str, Any]:
        """Crear un bloque de filtro para reducción de datos"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/block/filter"
        payload = {
            'notebookId': notebook_id,
            'blockTitle': title,
            'blockDescription': description
        }
        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_calculator_block(self, notebook_id: str, title: str, description: str) -> Dict[str, Any]:
        """Crear un bloque de calculadora para cómputo de métricas"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/block/calculator"
        payload = {
            'notebookId': notebook_id,
            'blockTitle': title,
            'blockDescription': description
        }
        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_alert_block(self, notebook_id: str, title: str, description: str) -> Dict[str, Any]:
        """Crear un bloque de alerta para monitoreo"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/block/alert"
        payload = {
            'notebookId': notebook_id,
            'blockTitle': title,
            'blockDescription': description
        }
        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_analysis_pipeline(self, notebook_id: str) -> Dict[str, Any]:
        """Crear un pipeline completo de análisis con todos los tipos de bloques"""
        pipeline = {}

        # Crear bloque de filtro
        pipeline['filter'] = self.create_filter_block(
            notebook_id,
            'Filtro de Datos',
            'Filtrar conjunto de datos para el alcance del análisis'
        )

        # Crear bloque calculadora
        pipeline['calculator'] = self.create_calculator_block(
            notebook_id,
            'Calculadora de Rendimiento',
            'Calcular métricas clave de rendimiento'
        )

        # Crear bloque de alerta
        pipeline['alert'] = self.create_alert_block(
            notebook_id,
            'Alerta de Rendimiento',
            'Monitorear umbrales de rendimiento'
        )

        return pipeline

# Ejemplo de uso
block_manager = BlockTypeManager(
    'https://your-mindzie-instance.com',
    'tenant-guid',
    'project-guid',
    'your-auth-token'
)

# Crear pipeline completo de análisis
pipeline = block_manager.create_analysis_pipeline('notebook-guid')
print(f"Pipeline creado con {len(pipeline)} bloques")

Notas Importantes

Dependencias de Bloques: Los bloques pueden encadenarse donde los bloques de filtro reducen los datos, los bloques calculadora calculan métricas y los bloques de alerta monitorean los resultados para detectar excepciones.

Mejores Prácticas: Comience con bloques de filtro para reducir el alcance de los datos, luego use bloques calculadora para análisis y finalmente agregue bloques de alerta para monitoreo continuo y notificaciones.