Gestión de Bloques

Obtener, Actualizar y Eliminar Bloques de Análisis

Administre los bloques de análisis dentro de los notebooks. Los bloques son las unidades fundamentales de análisis que realizan transformaciones de datos, cálculos, operaciones de filtrado y alertas.

Pruebas de Conectividad

Ping No Autorizado

GET /api/{tenantId}/{projectId}/block/unauthorized-ping

Punto final de prueba que no requiere autenticación. Úselo para verificar que la API de Bloques sea accesible.

Respuesta

Ping Successful

Ping Autenticado

GET /api/{tenantId}/{projectId}/block/ping

Punto final de ping autenticado para verificar el acceso a la API para un tenant y proyecto específicos.

Respuesta (200 OK)

Ping Successful (tenant id: {tenantId})

Respuesta (401 Unauthorized)

{error message describing authorization failure}

Obtener Detalles del Bloque

GET /api/{tenantId}/{projectId}/block/{blockId}

Recupera información completa sobre un bloque de análisis específico, incluyendo su configuración, historial de ejecución y metadatos.

Parámetros de Ruta

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

Respuesta (200 OK)

{
  "blockId": "550e8400-e29b-41d4-a716-446655440000",
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockType": "Filter",
  "blockTitle": "Date Range Filter",
  "blockDescription": "Filters data for the last 30 days",
  "blockOrder": 0,
  "configuration": "{\"filterType\": \"dateRange\", \"startDate\": \"2024-01-01\"}",
  "isDisabled": false,
  "dateCreated": "2024-01-15T10:30:00Z",
  "dateModified": "2024-01-15T14:45:00Z",
  "createdBy": "user@example.com",
  "modifiedBy": "user@example.com",
  "lastExecutionDate": "2024-01-15T14:45:00Z",
  "lastExecutionStatus": "Success",
  "executionCount": 12
}

Campos de Respuesta

Campo	Tipo	Descripción
blockId	GUID	Identificador único del bloque
notebookId	GUID	ID del notebook que contiene este bloque
blockType	string	Tipo de bloque (Filter, Calculator, Alert, etc.)
blockTitle	string	Título para mostrar del bloque
blockDescription	string	Descripción del propósito del bloque
blockOrder	integer	Orden del bloque en el notebook (predeterminado: 0)
configuration	string	Cadena JSON con configuración del bloque
isDisabled	boolean	Indica si el bloque está deshabilitado
dateCreated	datetime	Fecha en que se creó el bloque
dateModified	datetime	Fecha en que el bloque fue modificado por última vez
createdBy	string	Usuario que creó el bloque
modifiedBy	string	Usuario que modificó el bloque por última vez
lastExecutionDate	datetime	Fecha de la última ejecución del bloque
lastExecutionStatus	string	Estado de la última ejecución
executionCount	integer	Número de veces que el bloque ha sido ejecutado

Respuestas de Error

No Encontrado (404):

{
  "Error": "Block not found",
  "BlockId": "550e8400-e29b-41d4-a716-446655440000"
}

Actualizar Bloque

PUT /api/{tenantId}/{projectId}/block/{blockId}

Actualiza los metadatos de un bloque existente. Preserva el historial de ejecuciones mientras actualiza los campos especificados.

Cuerpo de la Solicitud

{
  "blockTitle": "Updated Date Filter",
  "blockDescription": "Filters data for custom date range",
  "isDisabled": false
}

Campos de la Solicitud

Campo	Tipo	Obligatorio	Descripción
blockTitle	string	No	Nuevo título para el bloque
blockDescription	string	No	Nueva descripción para el bloque
isDisabled	boolean	No	Indica si el bloque debe estar deshabilitado

Respuesta (200 OK)

Devuelve el objeto del bloque actualizado con la misma estructura que el endpoint GET.

Respuestas de Error

Solicitud Incorrecta (400):

Failed to update block.

Eliminar Bloque

DELETE /api/{tenantId}/{projectId}/block/{blockId}

Elimina permanentemente un bloque y todo su historial de ejecuciones del notebook. Esta operación no puede deshacerse.

Códigos de Respuesta

• 204 No Content - Bloque eliminado exitosamente
• 400 Bad Request - Fallo al eliminar el bloque
• 401 Unauthorized - No autenticado o sin acceso
• 404 Not Found - Bloque no encontrado

Creación de Bloques

La creación de bloques se maneja a través de la API de Notebook, no de la API de Bloques.

POST /api/{tenantId}/{projectId}/notebook/{notebookId}/blocks

Consulte Notebook API para la documentación completa sobre creación de bloques.

Ejemplos de Implementación

cURL

# Probar conectividad (sin autenticación)
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/unauthorized-ping"

# Probar conectividad (autenticado)
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/ping" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Obtener detalles del bloque
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/550e8400-e29b-41d4-a716-446655440000" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Actualizar bloque
curl -X PUT "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/550e8400-e29b-41d4-a716-446655440000" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"blockTitle": "Updated Filter", "isDisabled": false}'

# Eliminar bloque
curl -X DELETE "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/550e8400-e29b-41d4-a716-446655440000" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

JavaScript/Node.js

const TENANT_ID = '12345678-1234-1234-1234-123456789012';
const PROJECT_ID = '87654321-4321-4321-4321-210987654321';
const BASE_URL = 'https://your-mindzie-instance.com';

class BlockManager {
  constructor(token) {
    this.token = token;
    this.headers = {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    };
  }

  async getBlock(blockId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/block/${blockId}`;
    const response = await fetch(url, { headers: this.headers });

    if (response.ok) {
      return await response.json();
    } else if (response.status === 404) {
      throw new Error('Block not found');
    } else {
      throw new Error(`Failed to get block: ${response.status}`);
    }
  }

  async updateBlock(blockId, updates) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/block/${blockId}`;
    const response = await fetch(url, {
      method: 'PUT',
      headers: this.headers,
      body: JSON.stringify(updates)
    });

    if (response.ok) {
      return await response.json();
    } else {
      throw new Error(`Failed to update block: ${response.status}`);
    }
  }

  async deleteBlock(blockId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/block/${blockId}`;
    const response = await fetch(url, {
      method: 'DELETE',
      headers: this.headers
    });

    return response.status === 204;
  }
}

// Uso
const manager = new BlockManager('your-auth-token');

// Obtener detalles del bloque
const block = await manager.getBlock('block-guid');
console.log(`Block: ${block.blockTitle} (${block.blockType})`);

// Actualizar bloque
const updated = await manager.updateBlock('block-guid', {
  blockTitle: 'Updated Title',
  isDisabled: false
});

// Eliminar bloque
const deleted = await manager.deleteBlock('block-guid');

Python

import requests

TENANT_ID = '12345678-1234-1234-1234-123456789012'
PROJECT_ID = '87654321-4321-4321-4321-210987654321'
BASE_URL = 'https://your-mindzie-instance.com'

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

    def get_block(self, block_id):
        """Obtener detalles del bloque."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}'
        response = requests.get(url, headers=self.headers)

        if response.ok:
            return response.json()
        elif response.status_code == 404:
            raise Exception('Block not found')
        else:
            raise Exception(f'Failed to get block: {response.status_code}')

    def update_block(self, block_id, title=None, description=None, disabled=None):
        """Actualizar metadatos del bloque."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}'
        payload = {}
        if title is not None:
            payload['blockTitle'] = title
        if description is not None:
            payload['blockDescription'] = description
        if disabled is not None:
            payload['isDisabled'] = disabled

        response = requests.put(url, json=payload, headers=self.headers)

        if response.ok:
            return response.json()
        else:
            raise Exception(f'Failed to update block: {response.status_code}')

    def delete_block(self, block_id):
        """Eliminar un bloque."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}'
        response = requests.delete(url, headers=self.headers)
        return response.status_code == 204

# Uso
manager = BlockManager('your-auth-token')

# Obtener bloque
block = manager.get_block('block-guid')
print(f"Block: {block['blockTitle']} ({block['blockType']})")
print(f"Execution count: {block['executionCount']}")

# Actualizar bloque
updated = manager.update_block('block-guid', title='New Title', disabled=False)
print(f"Updated: {updated['blockTitle']}")

# Eliminar bloque
if manager.delete_block('block-guid'):
    print('Block deleted successfully')

C#

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class BlockReturn
{
    public Guid BlockId { get; set; }
    public Guid NotebookId { get; set; }
    public string BlockType { get; set; }
    public string BlockTitle { get; set; }
    public string BlockDescription { get; set; }
    public int BlockOrder { get; set; }
    public string Configuration { get; set; }
    public bool IsDisabled { get; set; }
    public DateTime DateCreated { get; set; }
    public DateTime DateModified { get; set; }
    public string CreatedBy { get; set; }
    public string ModifiedBy { get; set; }
    public DateTime? LastExecutionDate { get; set; }
    public string LastExecutionStatus { get; set; }
    public int ExecutionCount { get; set; }
}

public class BlockApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;
    private readonly Guid _tenantId;
    private readonly Guid _projectId;

    public BlockApiClient(string baseUrl, Guid tenantId, Guid projectId, string accessToken)
    {
        _baseUrl = baseUrl;
        _tenantId = tenantId;
        _projectId = projectId;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Authorization =
            new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
    }

    public async Task<BlockReturn> GetBlockAsync(Guid blockId)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/block/{blockId}";
        var response = await _httpClient.GetAsync(url);

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<BlockReturn>(json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        }

        throw new Exception($"Failed to get block: {response.StatusCode}");
    }

    public async Task<BlockReturn> UpdateBlockAsync(Guid blockId, string title, string description, bool? isDisabled)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/block/{blockId}";
        var payload = new
        {
            blockTitle = title,
            blockDescription = description,
            isDisabled = isDisabled
        };

        var content = new StringContent(
            JsonSerializer.Serialize(payload),
            Encoding.UTF8,
            "application/json");

        var response = await _httpClient.PutAsync(url, content);

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<BlockReturn>(json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        }

        throw new Exception($"Failed to update block: {response.StatusCode}");
    }

    public async Task<bool> DeleteBlockAsync(Guid blockId)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/block/{blockId}";
        var response = await _httpClient.DeleteAsync(url);
        return response.StatusCode == System.Net.HttpStatusCode.NoContent;
    }
}