Import & Export

Exportez des projets sous forme de fichiers .mpz portables pour la sauvegarde ou le transfert, et importez-les dans d'autres locataires. Gérez également les images miniatures des projets.

Paquets de Projet (.mpz)

Le format .mpz est un mindzie Package Zip contenant :

• Paramètres et métadonnées du projet
• Tous les ensembles de données et leurs configurations
• Investigations et notebooks
• Tableaux de bord et panneaux
• Fichiers de stockage blob (journaux d'événements, pièces jointes)

---

Exporter un Projet

GET /api/{tenantId}/project/{projectId}/download

Exporte le projet en tant que fichier .mpz (mindzie Package Zip).

Paramètres de Chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	L'identifiant du locataire
projectId	GUID	Oui	Le projet à exporter

Réponse

Retourne un fichier binaire à télécharger avec :

• Content-Type : application/octet-stream
• Nom de fichier : {projectName}.mpz

Cas d’Utilisation

• Sauvegarde : Créez des sauvegardes régulières des projets importants
• Migration : Déplacez les projets entre locataires ou instances
• Modèles : Exporte un projet configuré comme modèle pour de nouvelles analyses

---

Importer un Projet

POST /api/{tenantId}/project/import

Importe un projet à partir d’un fichier .mpz.

Paramètres de Chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Le locataire cible

Requête

• Content-Type : multipart/form-data
• Paramètre fichier : file (le fichier .mpz)

Contraintes

Contrainte	Valeur
Taille maximale du fichier	1 Go
Extension de fichier	Doit être .mpz
Format de fichier	Doit être une exportation de projet mindzie valide

Réponse (200 OK)

{
  "success": true,
  "projectId": "99999999-9999-9999-9999-999999999999",
  "projectName": "Imported Project",
  "datasetsImported": 2,
  "investigationsImported": 3,
  "dashboardsImported": 1,
  "message": "Project imported successfully"
}

Champs de la Réponse

Champ	Type	Description
success	boolean	Indique si l'importation a réussi
projectId	GUID	ID du projet nouvellement créé
projectName	string	Nom du projet importé
datasetsImported	integer	Nombre d’ensembles de données importés
investigationsImported	integer	Nombre d’investigations importées
dashboardsImported	integer	Nombre de tableaux de bord importés
message	string	Statut lisible par un humain

Réponses d’Erreur

Mauvaise Requête (400) :

{
  "success": false,
  "errorMessage": "Invalid file format. Expected .mpz file."
}

---

Gestion des Miniatures

Les miniatures de projet sont affichées dans la liste des projets et fournissent une identification visuelle.

Récupérer la Miniature

GET /api/{tenantId}/project/{projectId}/thumbnail

Récupère l'image miniature du projet.

Réponse (200 OK)

{
  "projectId": "87654321-4321-4321-4321-210987654321",
  "hasThumbnail": true,
  "base64Image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD..."
}

Champs de la Réponse

Champ	Type	Description
projectId	GUID	Identifiant du projet
hasThumbnail	boolean	Indique si une miniature existe
base64Image	string	Image encodée en base64 avec préfixe data URI

Mettre à Jour la Miniature

POST /api/{tenantId}/project/{projectId}/thumbnail

Met à jour l’image miniature du projet.

Corps de la Requête

{
  "base64Image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD..."
}

Note : La chaîne base64 doit inclure le préfixe data URI (ex. data:image/jpeg;base64, ou data:image/png;base64,).

Réponse (200 OK)

{
  "message": "Thumbnail updated successfully"
}

Supprimer la Miniature

DELETE /api/{tenantId}/project/{projectId}/thumbnail

Supprime l’image miniature du projet.

Réponse (200 OK)

{
  "message": "Thumbnail removed successfully"
}

---

Exemples d’Implémentation

cURL

# Exporter le projet vers un fichier
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/project/87654321-4321-4321-4321-210987654321/download" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  --output project_backup.mpz

# Importer le projet depuis un fichier
curl -X POST "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/project/import" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -F "file=@project_backup.mpz"

# Obtenir la miniature
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/project/87654321-4321-4321-4321-210987654321/thumbnail" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Mettre à jour la miniature (à partir d’un fichier base64)
curl -X POST "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/project/87654321-4321-4321-4321-210987654321/thumbnail" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"base64Image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUg..."}'

# Supprimer la miniature
curl -X DELETE "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/project/87654321-4321-4321-4321-210987654321/thumbnail" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

Python

import requests
import base64
from pathlib import Path

TENANT_ID = '12345678-1234-1234-1234-123456789012'
BASE_URL = 'https://your-mindzie-instance.com'

class ProjectExportManager:
    def __init__(self, token):
        self.headers = {
            'Authorization': f'Bearer {token}'
        }

    def export_project(self, project_id, output_path):
        """Exporter le projet au format .mpz."""
        url = f'{BASE_URL}/api/{TENANT_ID}/project/{project_id}/download'
        response = requests.get(url, headers=self.headers, stream=True)
        response.raise_for_status()

        with open(output_path, 'wb') as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)

        print(f"Exporté vers {output_path}")
        return output_path

    def import_project(self, file_path):
        """Importer un projet à partir d’un fichier .mpz."""
        url = f'{BASE_URL}/api/{TENANT_ID}/project/import'

        with open(file_path, 'rb') as f:
            files = {'file': (Path(file_path).name, f, 'application/octet-stream')}
            response = requests.post(url, headers=self.headers, files=files)

        response.raise_for_status()
        result = response.json()

        print(f"Importé : {result['projectName']}")
        print(f"  Ensembles de données : {result['datasetsImported']}")
        print(f"  Investigations : {result['investigationsImported']}")
        print(f"  Tableaux de bord : {result['dashboardsImported']}")

        return result

    def get_thumbnail(self, project_id):
        """Obtenir la miniature du projet en base64."""
        url = f'{BASE_URL}/api/{TENANT_ID}/project/{project_id}/thumbnail'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def set_thumbnail(self, project_id, image_path):
        """Définir la miniature du projet à partir d’un fichier image."""
        url = f'{BASE_URL}/api/{TENANT_ID}/project/{project_id}/thumbnail'

        # Lire et encoder l'image
        with open(image_path, 'rb') as f:
            image_data = f.read()

        # Déterminer le type MIME
        ext = Path(image_path).suffix.lower()
        mime_type = 'image/jpeg' if ext in ['.jpg', '.jpeg'] else 'image/png'

        # Créer une URI de données base64
        base64_data = base64.b64encode(image_data).decode('utf-8')
        data_uri = f'data:{mime_type};base64,{base64_data}'

        headers = {**self.headers, 'Content-Type': 'application/json'}
        response = requests.post(url, json={'base64Image': data_uri}, headers=headers)
        response.raise_for_status()

        print(f"Miniature mise à jour pour le projet {project_id}")
        return response.json()

    def remove_thumbnail(self, project_id):
        """Supprimer la miniature du projet."""
        url = f'{BASE_URL}/api/{TENANT_ID}/project/{project_id}/thumbnail'
        response = requests.delete(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

# Utilisation
manager = ProjectExportManager('your-auth-token')
project_id = '87654321-4321-4321-4321-210987654321'

# Exporter le projet pour sauvegarde
manager.export_project(project_id, 'my_project_backup.mpz')

# Importer dans le même ou un autre locataire
result = manager.import_project('my_project_backup.mpz')
new_project_id = result['projectId']

# Définir une miniature
manager.set_thumbnail(project_id, 'project_thumbnail.png')

# Obtenir la miniature
thumbnail = manager.get_thumbnail(project_id)
if thumbnail['hasThumbnail']:
    print("La miniature existe")

JavaScript/Node.js

const fs = require('fs');
const path = require('path');
const FormData = require('form-data');

const TENANT_ID = '12345678-1234-1234-1234-123456789012';
const BASE_URL = 'https://your-mindzie-instance.com';

class ProjectExportManager {
  constructor(token) {
    this.headers = {
      'Authorization': `Bearer ${token}`
    };
  }

  async exportProject(projectId, outputPath) {
    const url = `${BASE_URL}/api/${TENANT_ID}/project/${projectId}/download`;
    const response = await fetch(url, { headers: this.headers });

    if (!response.ok) {
      throw new Error(`Échec de l'exportation : ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    fs.writeFileSync(outputPath, Buffer.from(buffer));
    console.log(`Exporté vers ${outputPath}`);
  }

  async importProject(filePath) {
    const url = `${BASE_URL}/api/${TENANT_ID}/project/import`;

    const formData = new FormData();
    formData.append('file', fs.createReadStream(filePath));

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

    if (!response.ok) {
      throw new Error(`Échec de l'importation : ${response.status}`);
    }

    const result = await response.json();
    console.log(`Importé : ${result.projectName}`);
    return result;
  }

  async setThumbnail(projectId, imagePath) {
    const url = `${BASE_URL}/api/${TENANT_ID}/project/${projectId}/thumbnail`;

    // Lire et encoder l'image
    const imageBuffer = fs.readFileSync(imagePath);
    const ext = path.extname(imagePath).toLowerCase();
    const mimeType = ext === '.png' ? 'image/png' : 'image/jpeg';
    const base64Data = imageBuffer.toString('base64');
    const dataUri = `data:${mimeType};base64,${base64Data}`;

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

    if (!response.ok) {
      throw new Error(`Échec de la mise à jour de la miniature : ${response.status}`);
    }

    return await response.json();
  }
}

// Utilisation
const manager = new ProjectExportManager('your-auth-token');

// Exporter et importer
await manager.exportProject('project-id', 'backup.mpz');
const imported = await manager.importProject('backup.mpz');

// Définir une miniature
await manager.setThumbnail('project-id', 'thumbnail.png');

---

Bonnes Pratiques

1. Sauvegardes régulières : Planifiez des exportations régulières des projets importants
2. Nommage des versions : Incluez des dates dans les noms de fichiers d’export (ex. project_2024-01-15.mpz)
3. Tester les importations : Testez les importations dans un locataire non productif avant la production
4. Taille des miniatures : Gardez les miniatures sous 100KB pour un chargement rapide
5. Format des miniatures : Utilisez JPEG pour les photos, PNG pour les graphiques avec transparence