Datenimport

Daten aus mehreren Quellen importieren

Importieren Sie Daten aus CSV, Excel, JSON und anderen Formaten. Verarbeiten Sie große Datensätze mit Streaming-Uploads.

Daten-Datei hochladen

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

Laden Sie Daten aus verschiedenen Dateiformaten wie CSV, Excel und XES hoch und importieren Sie diese. Unterstützt große Datei-Uploads mit chunked Transfer.

Parameter

Parameter	Typ	Ort	Beschreibung
tenantId	GUID	Pfad	Der Mandantenbezeichner
projectId	GUID	Pfad	Der Projektbezeichner
datasetId	GUID	Pfad	Der Datensatzbezeichner
file	Datei	Formular-Daten	Die hochzuladende Datendatei
columnMapping	JSON	Formular-Daten	Konfiguration der Spaltenzuordnung

Spaltenzuordnungskonfiguration

{
  "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
  }
}

Antwort

{
  "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"
}

CSV mit Zuordnung importieren

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

Importieren Sie CSV-Daten mit erweiterten Spaltenzuordnungs-, Datenumwandlungs- und Validierungsoptionen.

Anfragekörper

{
  "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 "
    }
  ]
}

Antwort

Gibt das gleiche Importstatus-Objekt zurück wie der Dateiupload-Endpunkt.

Importstatus abrufen

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

Überwachen Sie den Fortschritt und Status eines Datenimportvorgangs einschließlich Validierungsergebnissen und Fehlerdetails.

Antwort

{
  "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": "Ungültiges Datumsformat",
      "value": "2024-13-01 25:00:00"
    }
  ],
  "warnings": [
    {
      "row": 2847,
      "column": "Resource",
      "warning": "Leerer Wert für optionales Feld",
      "value": ""
    }
  ],
  "statistics": {
    "uniqueCases": 1247,
    "uniqueActivities": 12,
    "dateRange": {
      "earliest": "2024-01-01T08:00:00Z",
      "latest": "2024-01-31T17:30:00Z"
    }
  }
}

Unterstützte Dateiformate

mindzieStudio unterstützt mehrere Datenformate für einen nahtlosen Import von Process Mining-Daten:

CSV-Dateien

Durch Komma getrennte Werte mit flexiblen Parsing-Optionen.

• Benutzerdefinierte Trennzeichen (Komma, Semikolon, Tabulator)
• Unterstützung für UTF-8, ISO-8859-1 Kodierung
• Erkennung der Kopfzeile
• Umgang mit Anführungszeichen

Excel-Dateien

Microsoft Excel-Arbeitsmappen (.xlsx, .xls).

• Unterstützung für mehrere Arbeitsblätter
• Beibehaltung der Zellformatierung
• Erkennung von Datum/Uhrzeit
• Streaming großer Dateien

XES-Format

IEEE XES-Standard für Process Mining.

• Volle Unterstützung der XES-Spezifikation
• Ereignisattributen und Erweiterungen
• Lebenszyklusinformationen
• Kompatibilität mit Process Mining Werkzeugen

JSON-Dateien

Strukturierte JSON-Daten für komplexe Ereignisse.

• Unterstützung verschachtelter Objekte
• Umgang mit Arrays
• Benutzerdefinierte Schema-Zuordnung
• Streaming-Verarbeitung von JSON

JavaScript-Beispiel: Datei-Upload mit Fortschritt

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); // Prüfe alle 2 Sekunden
        }
      } 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
      }
    };
  }
}

// Beispiel zur Nutzung
const importer = new DataImporter(
  'https://your-mindzie-instance.com',
  'tenant-guid',
  'project-guid',
  'your-token'
);

// Datei-Upload mit Fortschrittsüberwachung
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('Upload gestartet:', result.importId);

    // Fortschritt überwachen
    importer.monitorImport('dataset-guid', result.importId, (status) => {
      if (status.error) {
        console.error('Import fehlgeschlagen:', status.error);
      } else {
        const progress = (status.rowsProcessed / status.rowsTotal) * 100;
        console.log(`Fortschritt: ${progress.toFixed(1)}% (${status.rowsProcessed}/${status.rowsTotal})`);

        if (status.status === 'Completed') {
          console.log('Import erfolgreich abgeschlossen!');
          console.log(`Verarbeitete ${status.rowsProcessed} Zeilen mit ${status.errors.length} Fehlern`);
        }
      }
    });
  } catch (error) {
    console.error('Upload fehlgeschlagen:', error);
  }
});