Importeren & Exporteren

Exporteer projecten als portable .mpz-bestanden voor back-up of overdracht, en importeer ze in andere tenants. Beheer ook project-miniatuurafbeeldingen.

Projectpakketten (.mpz)

Het .mpz-formaat is een mindzie Package Zip die bevat:

• Projectinstellingen en metadata
• Alle datasets en hun configuraties
• Onderzoeken en notitieboeken
• Dashboards en panelen
• Blobopslagbestanden (gebeurtenislogboeken, bijlagen)

---

Project Exporteren

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

Exporteert het project als een .mpz (mindzie Package Zip) bestand.

Padparameters

Parameter	Type	Verplicht	Beschrijving
tenantId	GUID	Ja	De tenant-identificatie
projectId	GUID	Ja	Het te exporteren project

Respons

Geeft een binaire bestand-download terug met:

• Content-Type: application/octet-stream
• Bestandsnaam: {projectName}.mpz

Gebruiksscenario's

• Back-up: Maak regelmatige back-ups van belangrijke projecten
• Migratie: Verplaats projecten tussen tenants of instanties
• Templates: Exporteer een geconfigureerd project als sjabloon voor nieuwe analyses

---

Project Importeren

POST /api/{tenantId}/project/import

Importeert een project vanuit een .mpz-bestand.

Padparameters

Parameter	Type	Verplicht	Beschrijving
tenantId	GUID	Ja	De doel-tenant

Verzoek

• Content-Type: multipart/form-data
• Bestandsparameter: file (het .mpz-bestand)

Beperkingen

Beperking	Waarde
Maximale bestandsgrootte	1 GB
Bestandsextensie	Moet .mpz zijn
Bestandformaat	Moet een geldige mindzie projectexport zijn

Respons (200 OK)

{
  "success": true,
  "projectId": "99999999-9999-9999-9999-999999999999",
  "projectName": "Geïmporteerd Project",
  "datasetsImported": 2,
  "investigationsImported": 3,
  "dashboardsImported": 1,
  "message": "Project succesvol geïmporteerd"
}

Responsvelden

Veld	Type	Beschrijving
success	boolean	Of importeren geslaagd is
projectId	GUID	ID van het nieuw aangemaakte project
projectName	string	Naam van het geïmporteerde project
datasetsImported	integer	Aantal geïmporteerde datasets
investigationsImported	integer	Aantal geïmporteerde onderzoeken
dashboardsImported	integer	Aantal geïmporteerde dashboards
message	string	Menselijk leesbare status

Foutreacties

Bad Request (400):

{
  "success": false,
  "errorMessage": "Ongeldig bestandsformaat. Verwacht .mpz bestand."
}

---

Miniatuurbeheer

Project-miniaturen worden weergegeven in de projectenlijst en zorgen voor visuele herkenning.

Miniatuur Ophalen

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

Haalt de miniatuurafbeelding van het project op.

Respons (200 OK)

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

Responsvelden

Veld	Type	Beschrijving
projectId	GUID	Projectidentificatie
hasThumbnail	boolean	Of er een miniatuur bestaat
base64Image	string	Base64-gecodeerde afbeelding met data-URI prefix

Miniatuur Bijwerken

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

Werk de miniatuurafbeelding van het project bij.

Verzoek Body

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

Opmerking: De base64-string moet de data-URI prefix bevatten (bijv. data:image/jpeg;base64, of data:image/png;base64,).

Respons (200 OK)

{
  "message": "Miniatuur succesvol bijgewerkt"
}

Miniatuur Verwijderen

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

Verwijdert de miniatuurafbeelding van het project.

Respons (200 OK)

{
  "message": "Miniatuur succesvol verwijderd"
}

---

Implementatievoorbeelden

cURL

# Project exporteren naar bestand
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

# Project importeren vanuit bestand
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"

# Miniatuur ophalen
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"

# Miniatuur bijwerken (van base64 bestand)
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..."}'

# Miniatuur verwijderen
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):
        """Exporteer project naar .mpz bestand."""
        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"Geëxporteerd naar {output_path}")
        return output_path

    def import_project(self, file_path):
        """Importeer project vanuit .mpz bestand."""
        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"Geïmporteerd: {result['projectName']}")
        print(f"  Datasets: {result['datasetsImported']}")
        print(f"  Onderzoeken: {result['investigationsImported']}")
        print(f"  Dashboards: {result['dashboardsImported']}")

        return result

    def get_thumbnail(self, project_id):
        """Haal project-miniatuur op als 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):
        """Stel project-miniatuur in vanaf afbeeldingsbestand."""
        url = f'{BASE_URL}/api/{TENANT_ID}/project/{project_id}/thumbnail'

        # Lees en codeer afbeelding
        with open(image_path, 'rb') as f:
            image_data = f.read()

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

        # Maak base64 data URI
        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"Miniatuur bijgewerkt voor project {project_id}")
        return response.json()

    def remove_thumbnail(self, project_id):
        """Verwijder project-miniatuur."""
        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()

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

# Project exporteren voor back-up
manager.export_project(project_id, 'my_project_backup.mpz')

# Importeren in dezelfde of andere tenant
result = manager.import_project('my_project_backup.mpz')
new_project_id = result['projectId']

# Stel een miniatuur in
manager.set_thumbnail(project_id, 'project_thumbnail.png')

# Miniatuur ophalen
thumbnail = manager.get_thumbnail(project_id)
if thumbnail['hasThumbnail']:
    print("Miniatuur bestaat")

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(`Exporteren mislukt: ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    fs.writeFileSync(outputPath, Buffer.from(buffer));
    console.log(`Geëxporteerd naar ${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(`Importeren mislukt: ${response.status}`);
    }

    const result = await response.json();
    console.log(`Geïmporteerd: ${result.projectName}`);
    return result;
  }

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

    // Lees en codeer afbeelding
    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(`Miniatuur bijwerken mislukt: ${response.status}`);
    }

    return await response.json();
  }
}

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

// Exporteren en importeren
await manager.exportProject('project-id', 'backup.mpz');
const imported = await manager.importProject('backup.mpz');

// Miniatuur instellen
await manager.setThumbnail('project-id', 'thumbnail.png');

---

Best Practices

1. Regelmatige Back-ups: Plan regelmatige exports van belangrijke projecten
2. Versienaamgeving: Voeg datums toe in exportbestandsnamen (bijv. project_2024-01-15.mpz)
3. Test Imports: Test imports in een niet-productie tenant vóór productie
4. Miniatuurgrootte: Houd miniaturen onder 100KB voor snelle laadtijd
5. Miniatuurformaat: Gebruik JPEG voor foto's, PNG voor afbeeldingen met transparantie