Importación de Datos

Importar Datos de Múltiples Fuentes

Importa datos desde CSV, Excel, JSON y otros formatos. Maneja grandes conjuntos de datos con cargas por streaming.

Subir Archivo de Datos

POST /api/{tenantId}/{projectId}/dataset/{datasetId}/import

Sube e importa datos desde varios formatos de archivo incluyendo CSV, Excel y XES. Soporta cargas de archivos grandes con transferencia segmentada.

Parámetros

Parámetro	Tipo	Ubicación	Descripción
tenantId	GUID	Ruta	Identificador del tenant
projectId	GUID	Ruta	Identificador del proyecto
datasetId	GUID	Ruta	Identificador del conjunto de datos
file	Archivo	Datos de formulario	Archivo de datos a subir
columnMapping	JSON	Datos de formulario	Configuración de mapeo de columnas

Configuración de Mapeo de Columnas

{
  "mapping": [
    {
      "sourceColumn": "Case_ID",
      "targetColumn": "CaseID",
      "dataType": "string"
    },
    {
      "sourceColumn": "Event_Name",
      "targetColumn": "Activity",
      "dataType": "string"
    },
    {
      "sourceColumn": "Event_Time",
      "targetColumn": "Timestamp",
      "dataType": "datetime",
      "format": "yyyy-MM-dd HH:mm:ss"
    }
  ],
  "options": {
    "hasHeader": true,
    "delimiter": ",",
    "encoding": "UTF-8",
    "skipRows": 0
  }
}

Respuesta

{
  "importId": "import-550e8400-e29b-41d4-a716-446655440000",
  "datasetId": "550e8400-e29b-41d4-a716-446655440000",
  "status": "Processing",
  "fileName": "process_events.csv",
  "fileSize": 15728640,
  "rowsProcessed": 0,
  "rowsTotal": 50000,
  "errors": [],
  "warnings": [],
  "startTime": "2024-01-15T10:30:00Z"
}

Importar CSV con Mapeo

POST /api/{tenantId}/{projectId}/dataset/{datasetId}/import/csv

Importa datos CSV con opciones avanzadas de mapeo de columnas, transformación de datos y validación.

Cuerpo de la Solicitud

{
  "fileUrl": "https://your-storage.com/data/events.csv",
  "mapping": [
    {
      "sourceColumn": "order_id",
      "targetColumn": "CaseID",
      "dataType": "string",
      "required": true
    },
    {
      "sourceColumn": "step_name",
      "targetColumn": "Activity",
      "dataType": "string",
      "required": true
    },
    {
      "sourceColumn": "timestamp",
      "targetColumn": "Timestamp",
      "dataType": "datetime",
      "format": "ISO8601",
      "required": true
    },
    {
      "sourceColumn": "user_name",
      "targetColumn": "Resource",
      "dataType": "string",
      "required": false
    }
  ],
  "options": {
    "hasHeader": true,
    "delimiter": ",",
    "encoding": "UTF-8",
    "skipRows": 1,
    "validateData": true,
    "replaceExisting": false
  },
  "transformations": [
    {
      "column": "Activity",
      "type": "replace",
      "find": "ORDER_",
      "replace": "Order "
    }
  ]
}

Respuesta

Devuelve el mismo objeto de estado de importación que el endpoint de carga de archivos.

Obtener Estado de Importación

GET /api/{tenantId}/{projectId}/dataset/{datasetId}/import/{importId}/status

Monitorea el progreso y estado de una operación de importación de datos incluyendo resultados de validación y detalles de errores.

Respuesta

{
  "importId": "import-550e8400-e29b-41d4-a716-446655440000",
  "datasetId": "550e8400-e29b-41d4-a716-446655440000",
  "status": "Completed",
  "fileName": "process_events.csv",
  "fileSize": 15728640,
  "rowsProcessed": 49876,
  "rowsTotal": 50000,
  "rowsSkipped": 124,
  "startTime": "2024-01-15T10:30:00Z",
  "endTime": "2024-01-15T10:45:23Z",
  "duration": "00:15:23",
  "errors": [
    {
      "row": 1532,
      "column": "Timestamp",
      "error": "Invalid date format",
      "value": "2024-13-01 25:00:00"
    }
  ],
  "warnings": [
    {
      "row": 2847,
      "column": "Resource",
      "warning": "Empty value for optional field",
      "value": ""
    }
  ],
  "statistics": {
    "uniqueCases": 1247,
    "uniqueActivities": 12,
    "dateRange": {
      "earliest": "2024-01-01T08:00:00Z",
      "latest": "2024-01-31T17:30:00Z"
    }
  }
}

Formatos de Archivo Soportados

mindzieStudio soporta múltiples formatos de datos para una importación fluida de datos de minería de procesos:

Archivos CSV

Valores separados por comas con opciones flexibles de análisis.

• Delimitadores personalizados (coma, punto y coma, tabulador)
• Soporte de codificación UTF-8, ISO-8859-1
• Detección de fila encabezado
• Manejo de caracteres de comillas

Archivos Excel

Libros de Microsoft Excel (.xlsx, .xls).

• Soporte de múltiples hojas de cálculo
• Preservación de formato de celdas
• Reconocimiento de fecha/hora
• Streaming para archivos grandes

Formato XES

Estándar IEEE XES para minería de procesos.

• Soporte completo de especificación XES
• Atributos y extensiones de evento
• Información de ciclo de vida
• Compatibilidad con herramientas de minería de procesos

Archivos JSON

Datos JSON estructurados para eventos complejos.

• Soporte de objetos anidados
• Manejo de arreglos
• Mapeo de esquema personalizado
• Procesamiento de JSON por streaming

Ejemplo en JavaScript: Subida de Archivo con Progreso

class DataImporter {
  constructor(baseUrl, tenantId, projectId, token) {
    this.baseUrl = baseUrl;
    this.tenantId = tenantId;
    this.projectId = projectId;
    this.headers = {
      'Authorization': `Bearer ${token}`
    };
  }

  async uploadFile(datasetId, file, columnMapping) {
    const formData = new FormData();
    formData.append('file', file);
    formData.append('columnMapping', JSON.stringify(columnMapping));

    const url = `${this.baseUrl}/api/${this.tenantId}/${this.projectId}/dataset/${datasetId}/import`;

    const response = await fetch(url, {
      method: 'POST',
      headers: this.headers,
      body: formData
    });

    return await response.json();
  }

  async importCsv(datasetId, csvConfig) {
    const url = `${this.baseUrl}/api/${this.tenantId}/${this.projectId}/dataset/${datasetId}/import/csv`;

    const response = await fetch(url, {
      method: 'POST',
      headers: {
        ...this.headers,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(csvConfig)
    });

    return await response.json();
  }

  async getImportStatus(datasetId, importId) {
    const url = `${this.baseUrl}/api/${this.tenantId}/${this.projectId}/dataset/${datasetId}/import/${importId}/status`;

    const response = await fetch(url, {
      headers: this.headers
    });

    return await response.json();
  }

  async monitorImport(datasetId, importId, callback) {
    const checkStatus = async () => {
      try {
        const status = await this.getImportStatus(datasetId, importId);
        callback(status);

        if (status.status === 'Processing') {
          setTimeout(checkStatus, 2000); // Revisar cada 2 segundos
        }
      } catch (error) {
        callback({ error: error.message });
      }
    };

    checkStatus();
  }

  buildStandardMapping() {
    return {
      mapping: [
        {
          sourceColumn: 'case_id',
          targetColumn: 'CaseID',
          dataType: 'string'
        },
        {
          sourceColumn: 'activity',
          targetColumn: 'Activity',
          dataType: 'string'
        },
        {
          sourceColumn: 'timestamp',
          targetColumn: 'Timestamp',
          dataType: 'datetime',
          format: 'ISO8601'
        }
      ],
      options: {
        hasHeader: true,
        delimiter: ',',
        encoding: 'UTF-8',
        validateData: true
      }
    };
  }
}

// Ejemplo de uso
const importer = new DataImporter(
  'https://your-mindzie-instance.com',
  'tenant-guid',
  'project-guid',
  'your-token'
);

// Manejar la subida de archivo con monitoreo de progreso
document.getElementById('fileInput').addEventListener('change', async (e) => {
  const file = e.target.files[0];
  if (!file) return;

  const mapping = importer.buildStandardMapping();

  try {
    const result = await importer.uploadFile('dataset-guid', file, mapping);
    console.log('Carga iniciada:', result.importId);

    // Monitorear progreso
    importer.monitorImport('dataset-guid', result.importId, (status) => {
      if (status.error) {
        console.error('Importación fallida:', status.error);
      } else {
        const progress = (status.rowsProcessed / status.rowsTotal) * 100;
        console.log(`Progreso: ${progress.toFixed(1)}% (${status.rowsProcessed}/${status.rowsTotal})`);

        if (status.status === 'Completed') {
          console.log('Importación completada exitosamente!');
          console.log(`Procesadas ${status.rowsProcessed} filas con ${status.errors.length} errores`);
        }
      }
    });
  } catch (error) {
    console.error('Carga fallida:', error);
  }
});