Cuadernos de Investigación

Acceda a los cuadernos dentro de una investigación. Los cuadernos contienen los bloques de análisis que definen los flujos de trabajo de minería de procesos.

Requisitos Previos

Antes de acceder a los cuadernos a través de esta API, debe cargar el proyecto en caché utilizando la API de Proyectos.

# Primero cargue el proyecto en caché
curl -X GET "https://your-mindzie-instance.com/api/{tenantId}/project/{projectId}/load" \
  -H "Authorization: Bearer YOUR_API_KEY"

Consulte Project Cache API para más detalles.

Listar Cuadernos de Investigación

GET /api/{tenantId}/{projectId}/investigation/{investigationId}/notebooks

Obtiene todos los cuadernos dentro de una investigación desde la caché del proyecto.

Parámetros de Ruta

Parámetro Tipo Obligatorio Descripción
tenantId GUID Sí El identificador del tenant
projectId GUID Sí El identificador del proyecto
investigationId GUID Sí El identificador de la investigación

Respuesta (200 OK)

{
  "notebooks": [
    {
      "notebookId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
      "investigationId": "11111111-2222-3333-4444-555555555555",
      "name": "Main",
      "description": "",
      "dateCreated": "2024-01-15T10:30:00Z",
      "dateModified": "2024-01-20T14:45:00Z",
      "createdBy": null,
      "modifiedBy": null,
      "notebookType": null,
      "notebookOrder": 1.0,
      "lastExecutionDuration": 0,
      "blockCount": 12
    },
    {
      "notebookId": "bbbbbbbb-cccc-dddd-eeee-ffffffffffff",
      "investigationId": "11111111-2222-3333-4444-555555555555",
      "name": "Variant Analysis",
      "description": "",
      "dateCreated": "2024-01-16T09:00:00Z",
      "dateModified": "2024-01-18T11:30:00Z",
      "createdBy": null,
      "modifiedBy": null,
      "notebookType": null,
      "notebookOrder": 2.0,
      "lastExecutionDuration": 0,
      "blockCount": 8
    }
  ],
  "totalCount": 2
}

Campos del Objeto Cuaderno

Campo Tipo Descripción
notebookId GUID Identificador único del cuaderno
investigationId GUID Investigación a la que pertenece este cuaderno
name string Nombre para mostrar del cuaderno
description string Descripción del cuaderno
dateCreated datetime Fecha en que se creó el cuaderno
dateModified datetime Fecha de la última modificación del cuaderno
createdBy GUID Usuario que creó el cuaderno
modifiedBy GUID Usuario que modificó por última vez el cuaderno
notebookType integer Tipo de cuaderno (0 = estándar)
notebookOrder decimal Orden de visualización dentro de la investigación
lastExecutionDuration double Duración de la última ejecución en segundos
blockCount integer Número de bloques en el cuaderno

Respuestas de Error

No Encontrado (404) - Proyecto no almacenado en caché:

"Project not found in cache. Please load the project first using the ProjectController.LoadProject endpoint."

No Encontrado (404) - Investigación no encontrada:

{
  "error": "Investigation not found",
  "investigationId": "11111111-2222-3333-4444-555555555555"
}

Obtener Cuaderno Principal

GET /api/{tenantId}/{projectId}/investigation/{investigationId}/main-notebook

Obtiene el cuaderno principal para una investigación. El cuaderno principal se crea automáticamente al crear una investigación y generalmente contiene el flujo de trabajo principal de filtrado y análisis.

Parámetros de Ruta

Parámetro Tipo Obligatorio Descripción
tenantId GUID Sí El identificador del tenant
projectId GUID Sí El identificador del proyecto
investigationId GUID Sí El identificador de la investigación

Respuesta (200 OK)

{
  "notebookId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
  "investigationId": "11111111-2222-3333-4444-555555555555",
  "name": "Main",
  "description": "Primary analysis notebook",
  "dateCreated": "2024-01-15T10:30:00Z",
  "dateModified": "2024-01-20T14:45:00Z",
  "createdBy": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "modifiedBy": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "notebookType": 0,
  "notebookOrder": 1.0,
  "lastExecutionDuration": 2.5,
  "blockCount": 12
}

Respuestas de Error

No Encontrado (404) - Investigación no encontrada:

{
  "error": "Investigation not found",
  "investigationId": "11111111-2222-3333-4444-555555555555"
}

No Encontrado (404) - Cuaderno principal no encontrado:

{
  "error": "Main notebook not found for investigation",
  "investigationId": "11111111-2222-3333-4444-555555555555"
}

Ejemplos de Implementación

cURL

# Paso 1: Primero cargue el proyecto en caché
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/project/87654321-4321-4321-4321-210987654321/load" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Paso 2: Listar todos los cuadernos en una investigación
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/investigation/11111111-2222-3333-4444-555555555555/notebooks" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Obtener el cuaderno principal directamente
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/investigation/11111111-2222-3333-4444-555555555555/main-notebook" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

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

    def load_project(self):
        """Cargar el proyecto en caché antes de acceder a los cuadernos."""
        url = f'{BASE_URL}/api/{TENANT_ID}/project/{PROJECT_ID}/load'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def list_notebooks(self, investigation_id):
        """Listar todos los cuadernos en una investigación."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/investigation/{investigation_id}/notebooks'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def get_main_notebook(self, investigation_id):
        """Obtener el cuaderno principal de una investigación."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/investigation/{investigation_id}/main-notebook'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

# Uso
accessor = NotebookAccessor('your-auth-token')
investigation_id = '11111111-2222-3333-4444-555555555555'

# Paso 1: Cargar proyecto en caché
print("Cargando proyecto en caché...")
load_result = accessor.load_project()
print(f"Proyecto cargado: {load_result['projectName']}")

# Paso 2: Listar cuadernos
notebooks = accessor.list_notebooks(investigation_id)
print(f"\nSe encontraron {notebooks['totalCount']} cuadernos:")

for nb in notebooks['notebooks']:
    print(f"  - {nb['name']}: {nb['blockCount']} bloques")

# Obtener cuaderno principal
main = accessor.get_main_notebook(investigation_id)
print(f"\nCuaderno principal: {main['name']} ({main['blockCount']} bloques)")

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 NotebookAccessor {
  constructor(token) {
    this.headers = {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    };
  }

  async loadProject() {
    const url = `${BASE_URL}/api/${TENANT_ID}/project/${PROJECT_ID}/load`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    return await response.json();
  }

  async listNotebooks(investigationId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/investigation/${investigationId}/notebooks`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    return await response.json();
  }

  async getMainNotebook(investigationId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/investigation/${investigationId}/main-notebook`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    return await response.json();
  }
}

// Uso
const accessor = new NotebookAccessor('your-auth-token');
const investigationId = '11111111-2222-3333-4444-555555555555';

// Paso 1: Cargar proyecto en caché
console.log('Cargando proyecto en caché...');
const loadResult = await accessor.loadProject();
console.log(`Proyecto cargado: ${loadResult.projectName}`);

// Paso 2: Listar cuadernos
const notebooks = await accessor.listNotebooks(investigationId);
console.log(`\nSe encontraron ${notebooks.totalCount} cuadernos:`);

notebooks.notebooks.forEach(nb => {
  console.log(`  - ${nb.name}: ${nb.blockCount} bloques`);
});

// Obtener cuaderno principal
const main = await accessor.getMainNotebook(investigationId);
console.log(`\nCuaderno principal: ${main.name} (${main.blockCount} bloques)`);

Mejores Prácticas

  1. Siempre Cargue el Proyecto Primero: Antes de acceder a los cuadernos, asegúrese de que el proyecto esté cargado en caché
  2. Duración de la Caché: Los proyectos permanecen en caché durante 30 minutos después del último acceso
  3. Actualizar Sesión: Las llamadas API extienden automáticamente la vida útil de la caché
  4. Use el Cuaderno Principal: Para análisis básicos, el cuaderno principal contiene el flujo de trabajo primario
  5. Orden de los Cuadernos: Los cuadernos se ordenan por notebookOrder para una visualización coherente