Importation de Données

Importer des données provenant de plusieurs sources

Importez des données aux formats CSV, Excel, JSON et autres. Gérez de grands ensembles de données avec des téléchargements en streaming.

Télécharger un Fichier de Données

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

Téléchargez et importez des données à partir de divers formats de fichiers incluant CSV, Excel et XES. Supporte les téléchargements de grands fichiers avec transfert par morceaux.

Paramètres

Paramètre	Type	Emplacement	Description
tenantId	GUID	Chemin	L'identifiant du locataire
projectId	GUID	Chemin	L'identifiant du projet
datasetId	GUID	Chemin	L'identifiant de l'ensemble de données
file	Fichier	Données de formulaire	Fichier de données à télécharger
columnMapping	JSON	Données de formulaire	Configuration de mappage des colonnes

Configuration du Mappage des Colonnes

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

Réponse

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

Importer un CSV avec Mappage

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

Importez des données CSV avec des options avancées de mappage des colonnes, transformation des données, et validation.

Corps de la Requête

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

Réponse

Retourne le même objet de statut d'importation que le point de terminaison de téléchargement de fichier.

Obtenir le Statut d'Importation

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

Surveillez la progression et le statut d'une opération d'importation de données, y compris les résultats de validation et les détails des erreurs.

Réponse

{
  "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": "Format de date invalide",
      "value": "2024-13-01 25:00:00"
    }
  ],
  "warnings": [
    {
      "row": 2847,
      "column": "Resource",
      "warning": "Valeur vide pour un champ optionnel",
      "value": ""
    }
  ],
  "statistics": {
    "uniqueCases": 1247,
    "uniqueActivities": 12,
    "dateRange": {
      "earliest": "2024-01-01T08:00:00Z",
      "latest": "2024-01-31T17:30:00Z"
    }
  }
}

Formats de Fichiers Pris en Charge

mindzieStudio prend en charge plusieurs formats de données pour une importation fluide des données de process mining :

Fichiers CSV

Valeurs séparées par des virgules avec options de parsing flexibles.

• Délimiteurs personnalisés (virgule, point-virgule, tabulation)
• Prise en charge des encodages UTF-8, ISO-8859-1
• Détection de ligne d'en-tête
• Gestion des guillemets

Fichiers Excel

Classeurs Microsoft Excel (.xlsx, .xls).

• Support de plusieurs feuilles de calcul
• Préservation du formatage des cellules
• Reconnaissance des dates/horaires
• Streaming pour gros fichiers

Format XES

Standard IEEE XES pour le process mining.

• Support complet de la spécification XES
• Attributs d'événements et extensions
• Informations sur le cycle de vie
• Compatibilité avec les outils de process mining

Fichiers JSON

Données JSON structurées pour événements complexes.

• Support des objets imbriqués
• Gestion des tableaux
• Mappage de schéma personnalisé
• Traitement JSON en streaming

Exemple JavaScript : Téléversement de Fichier avec Suivi de Progression

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); // Vérifier toutes les 2 secondes
        }
      } 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
      }
    };
  }
}

// Exemple d'utilisation
const importer = new DataImporter(
  'https://your-mindzie-instance.com',
  'tenant-guid',
  'project-guid',
  'your-token'
);

// Gérer le téléchargement de fichier avec suivi de progression
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('Téléversement démarré :', result.importId);

    // Surveiller la progression
    importer.monitorImport('dataset-guid', result.importId, (status) => {
      if (status.error) {
        console.error('Importation échouée :', status.error);
      } else {
        const progress = (status.rowsProcessed / status.rowsTotal) * 100;
        console.log(`Progression : ${progress.toFixed(1)}% (${status.rowsProcessed}/${status.rowsTotal})`);

        if (status.status === 'Completed') {
          console.log('Importation terminée avec succès !');
          console.log(`Traitement de ${status.rowsProcessed} lignes avec ${status.errors.length} erreurs`);
        }
      }
    });
  } catch (error) {
    console.error('Échec du téléversement :', error);
  }
});