Gestión del Panel de Control

Listar y Recuperar Paneles de Control

Acceda a los paneles de control que contienen paneles de visualización para perspectivas de minería de procesos, KPIs y análisis. Los paneles de control son contenedores para mostrar sus resultados analíticos en un formato organizado y compartible.

Pruebas de Conectividad

Ping No Autorizado

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

Punto final de prueba que no requiere autenticación. Use esto para verificar que la API del Panel de Control es accesible.

Respuesta

Ping Successful

Ping Autenticado

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

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

Respuesta (200 OK)

Ping Successful (tenant id: {tenantId})

Respuesta (401 Unauthorized)

{error message describing authorization failure}

Listar Todos los Paneles de Control

GET /api/{tenantId}/{projectId}/dashboard

Recupera una lista paginada de todos los paneles de control dentro del proyecto especificado. Cada panel incluye metadatos, contador de paneles y una URL para compartir.

Parámetros de Ruta

Parámetro	Tipo	Obligatorio	Descripción
tenantId	GUID	Sí	El identificador del inquilino
projectId	GUID	Sí	El identificador del proyecto

Parámetros de Consulta

Parámetro	Tipo	Por defecto	Descripción
page	entero	1	Número de página para paginación
pageSize	entero	50	Número de elementos por página (máximo recomendado: 100)

Respuesta (200 OK)

{
  "dashboards": [
    {
      "dashboardId": "880e8400-e29b-41d4-a716-446655440000",
      "projectId": "660e8400-e29b-41d4-a716-446655440000",
      "name": "Process Overview Dashboard",
      "description": "Main dashboard showing key process metrics",
      "panelCount": 8,
      "url": "https://your-instance.com/dashboard/880e8400-e29b-41d4-a716-446655440000",
      "dateCreated": "2024-01-15T10:30:00Z",
      "dateModified": "2024-01-20T14:45:00Z",
      "createdBy": "user@example.com",
      "modifiedBy": "user@example.com"
    }
  ],
  "totalCount": 25,
  "page": 1,
  "pageSize": 50
}

Campos de Respuesta

Campo	Tipo	Descripción
dashboards	array	Lista de objetos panel de control
totalCount	entero	Número total de paneles de control
page	entero	Número de página actual
pageSize	entero	Elementos por página

Campos del Objeto del Panel de Control

Campo	Tipo	Descripción
dashboardId	GUID	Identificador único del panel de control
projectId	GUID	Proyecto al que pertenece este panel
name	string	Nombre para mostrar del panel de control
description	string	Descripción del panel de control
panelCount	entero	Número de paneles en el panel de control
url	string	URL compartible para el panel de control
dateCreated	datetime	Fecha en que se creó el panel de control
dateModified	datetime	Fecha en que se modificó por última vez
createdBy	string	Usuario que creó el panel de control
modifiedBy	string	Usuario que modificó el panel de control por última vez

Obtener Detalles del Panel de Control

GET /api/{tenantId}/{projectId}/dashboard/{dashboardId}

Recupera información completa sobre un panel de control específico, incluyendo metadatos, contador de paneles y URL compartible.

Parámetros de Ruta

Parámetro	Tipo	Obligatorio	Descripción
tenantId	GUID	Sí	El identificador del inquilino
projectId	GUID	Sí	El identificador del proyecto
dashboardId	GUID	Sí	El identificador del panel de control

Respuesta (200 OK)

{
  "dashboardId": "880e8400-e29b-41d4-a716-446655440000",
  "projectId": "660e8400-e29b-41d4-a716-446655440000",
  "name": "Process Overview Dashboard",
  "description": "Main dashboard showing key process metrics and performance indicators",
  "panelCount": 8,
  "url": "https://your-instance.com/dashboard/880e8400-e29b-41d4-a716-446655440000",
  "dateCreated": "2024-01-15T10:30:00Z",
  "dateModified": "2024-01-20T14:45:00Z",
  "createdBy": "user@example.com",
  "modifiedBy": "user@example.com"
}

Respuestas de Error

No Encontrado (404):

{
  "Error": "Dashboard not found",
  "DashboardId": "880e8400-e29b-41d4-a716-446655440000"
}

Creación de Paneles de Control

La creación de paneles de control se gestiona a través de la interfaz de mindzieStudio, ya que requiere contexto de investigación y relaciones con notebooks. Consulte Resumen del Panel de Control para más detalles.

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/dashboard/unauthorized-ping"

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

# Listar todos los paneles de control
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/dashboard?page=1&pageSize=50" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Obtener panel de control específico
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/dashboard/880e8400-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 DashboardManager {
  constructor(token) {
    this.headers = {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    };
  }

  async getAllDashboards(page = 1, pageSize = 50) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/dashboard?page=${page}&pageSize=${pageSize}`;
    const response = await fetch(url, { headers: this.headers });
    return await response.json();
  }

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

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

  async listAllDashboards() {
    const allDashboards = [];
    let page = 1;

    while (true) {
      const result = await this.getAllDashboards(page);
      allDashboards.push(...result.dashboards);

      if (allDashboards.length >= result.totalCount) {
        break;
      }
      page++;
    }

    return allDashboards;
  }
}

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

// Obtener todos los paneles de control
const result = await manager.getAllDashboards();
console.log(`Se encontraron ${result.totalCount} paneles de control`);

result.dashboards.forEach(d => {
  console.log(`- ${d.name}: ${d.panelCount} paneles`);
  console.log(`  URL: ${d.url}`);
});

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 DashboardManager:
    def __init__(self, token):
        self.headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }

    def get_all_dashboards(self, page=1, page_size=50):
        """Obtener lista paginada de paneles de control."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/dashboard'
        params = {'page': page, 'pageSize': page_size}
        response = requests.get(url, headers=self.headers, params=params)
        return response.json()

    def get_dashboard(self, dashboard_id):
        """Obtener detalles del panel de control."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/dashboard/{dashboard_id}'
        response = requests.get(url, headers=self.headers)

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

    def list_all_dashboards(self):
        """Obtener todos los paneles de control (manejo de paginación)."""
        all_dashboards = []
        page = 1

        while True:
            result = self.get_all_dashboards(page=page)
            all_dashboards.extend(result['dashboards'])

            if len(all_dashboards) >= result['totalCount']:
                break
            page += 1

        return all_dashboards

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

# Obtener todos los paneles de control
dashboards = manager.get_all_dashboards()
print(f"Total de paneles de control: {dashboards['totalCount']}")

for dashboard in dashboards['dashboards']:
    print(f"\nPanel de control: {dashboard['name']}")
    print(f"  Paneles: {dashboard['panelCount']}")
    print(f"  URL: {dashboard['url']}")

C#

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

public class DashboardListReturn
{
    public List<DashboardReturn> Dashboards { get; set; }
    public int TotalCount { get; set; }
    public int Page { get; set; }
    public int PageSize { get; set; }
}

public class DashboardReturn
{
    public Guid DashboardId { get; set; }
    public Guid ProjectId { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public int PanelCount { get; set; }
    public string Url { get; set; }
    public DateTime DateCreated { get; set; }
    public DateTime DateModified { get; set; }
    public string CreatedBy { get; set; }
    public string ModifiedBy { get; set; }
}

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

    public DashboardApiClient(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<DashboardListReturn> GetAllDashboardsAsync(int page = 1, int pageSize = 50)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/dashboard?page={page}&pageSize={pageSize}";
        var response = await _httpClient.GetAsync(url);

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

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

    public async Task<DashboardReturn> GetDashboardAsync(Guid dashboardId)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/dashboard/{dashboardId}";
        var response = await _httpClient.GetAsync(url);

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<DashboardReturn>(json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        }
        else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
        {
            throw new Exception($"Dashboard {dashboardId} not found");
        }

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