API-Überblick

#!/bin/bash
# Minimales Bash-Skript zum Hochladen einer Datei nach ProcessMind mit zwei curl-Befehlen, Platzhalter für alle Werte

# Ersetzen Sie die folgenden Platzhalter durch Ihre echten Werte:
# <API_KEY>, <TENANT_ID>, <DATATABLE_ID>, <FILE_PATH>

curl -s -H "x-API-key: <API_KEY>" \
	"https://api.processmind.com/tenant/<TENANT_ID>/datatable/<DATATABLE_ID>/uploads/presignedurl" \
	| grep -oP '"PreSignedUploadUrl"\s*:\s*"\K[^"]+' \
	| xargs -I {} curl -s -X PUT --upload-file "<FILE_PATH>" "{}"

/**
 * Lädt eine lokale CSV-Datei per presigned URL zu ProcessMind hoch.
 *
 * Schritte:
 * 1. Hole eine presigned Upload-URL von der API.
 * 2. Lese die lokale Datei vom Datenträger.
 * 3. Lade die Datei per HTTP PUT auf die presigned URL hoch.
 *
 * Konfiguration:
 * – Geben Sie Ihren API-Key, tenantId, datatableId und filePath beim Aufruf von uploadFileToProcessMind() an.
 * – Die API-Basis-URL ist https://api.processmind.com
 */

const fs = require("node:fs");

/**
 * Lädt eine Datei per presigned URL in eine ProcessMind Datentable hoch.
 * @param {string} APIKey – Ihr API-Key zur Authentifizierung.
 * @param {string} tenantId – Ihr Tenant-Identifikator.
 * @param {string} datatableId – Ihr Datentable-Identifikator.
 * @param {string} filePath – Pfad zur Datei, die hochgeladen werden soll.
 */

async function getApi({path, APIKey, APIUrl = "https://api.processmind.com"}) {
	try {
        const response = await fetch(`${APIUrl}${path}`, {
            method: "GET",
            headers: {
                "x-API-key": APIKey
            }
        });
        const body = await response.json();
        if (!response.ok) {
            console.error(`Fehler beim Laden von der API: ${response.status}, ${response.statusText}: ${body.message}`);
            return;
        }
        return body;
    } catch (err) {
        console.error("Unerwarteter Fehler:", err);
    }
}

async function getPresignedUploadUrl({APIKey, tenantId, datatableId, APIUrl = "https://api.processmind.com"}) {
	return (await getApi({APIKey, path: `/tenant/${tenantId}/datatable/${datatableId}/uploads/presignedurl`, APIUrl})).PreSignedUploadUrl;
}

async function getDatensets({APIKey, tenantId, APIUrl = "https://api.processmind.com"}) {
	return await getApi({APIKey, path: `/tenant/${tenantId}/Datensatzs`, APIUrl});
}

async function getTenant({APIKey, tenantId, APIUrl = "https://api.processmind.com"}) {
	return await getApi({APIKey, path: `/tenant/${tenantId}`, APIUrl});
}

async function getOrganization({APIKey, tenantId, APIUrl = "https://api.processmind.com"}) {
	return await getApi({APIKey, path: `/tenant/${tenantId}/organization`, APIUrl});
}

async function uploadFile({APIKey, tenantId, datatableId, filePath, APIUrl = "https://api.processmind.com"}) {
    try {
        const uploadUrl = await getPresignedUploadUrl({APIKey, tenantId, datatableId, APIUrl});

		console.log("Datei wird hochgeladen...");
        fs.readFile(filePath, async (err, data) => {
            if (err) {
                console.error("Fehler beim Lesen der Datei:", err);
                return;
            }
            try {
                const uploadRes = await fetch(uploadUrl, {
                    method: "PUT",
                    body: data
                });
                if (!uploadRes.ok) {
                    console.error("Upload fehlgeschlagen:", uploadRes.status, uploadRes.statusText);
                } else {
                    console.log("Datei erfolgreich hochgeladen.");
                }
            } catch (uploadErr) {
                console.error("Fehler beim Hochladen der Datei:", uploadErr);
            }
        });
    } catch (err) {
        console.error("Unerwarteter Fehler:", err);
    }
}

// Exportiert die Funktionen für andere Module
module.exports = { 
	getPresignedUploadUrl,
	getDatensets,
	getTenant,
	getOrganization,
	uploadFile 
};

"""
Lädt eine lokale CSV-Datei mit einer presigned URL zu einer externen API hoch.

Steps:
1. Presigned Upload-URL bei der API abfragen.
2. Lokale Datei vom Datenträger lesen.
3. Datei per HTTP PUT auf die presigned URL hochladen.

Configuration:
- Aktualisieren Sie API_key, tenant_id, datatable_id, file_path entsprechend.
"""

import requests

# === Konfiguration ===
API_key = ""  # API-Key zur Authentifizierung
tenant_id = ""  # Tenant-Kennung
datatable_id = ""  # Datentable-Kennung
file_path = ""  # Pfad zur hochzuladenden Datei


print("Upload-URL wird abgerufen ...")
API_url = "https://api.processmind.com"  # Basis-API-URL
presign_url = f"{API_url}/tenant/{tenant_id}/datatable/{datatable_id}/uploads/presignedurl"
presign_res = requests.get(presign_url, headers={"x-API-key": API_key})
if not presign_res.ok:
	print(f"Fehler beim Abrufen der Upload-URL: {presign_res.status_code}, {presign_res.reason}: {presign_res.text}")
	exit(1)

presign_body = presign_res.json()
upload_url = presign_body.get("PreSignedUploadUrl")
if not upload_url:
	print("Keine signierte Upload-URL erhalten.")
	exit(1)

print("Datei wird hochgeladen ...")
with open(file_path, "rb") as f:
	upload_res = requests.put(upload_url, data=f)
if not upload_res.ok:
	print(f"Upload fehlgeschlagen: {upload_res.status_code}, {upload_res.reason}")
else:
	print("Datei erfolgreich hochgeladen.")