Das ist eine für den Ausdruck optimierte Ansicht des gesamten Kapitels inkl. Unterseiten. Druckvorgang starten.

Zur Standardansicht zurückkehren.

Dokumentation

Wir arbeiten ständig an der Weiterentwicklung von omniac Business; daher können die Dokumentation und die API noch Änderungen unterliegen. Wir werden Sie über alle Neuerungen auf dem Laufenden halten.

1 - Getting Started

Diese Sektion beschreibt die Einrichtung von omniac Business und den Start der Überwachung.

In dieser Sektion werden die ersten Schritte mit omniac Business beschrieben, darunter das Starten der Überwachung eines Benutzers, das Abfragen von Warnmeldungen und das Abfragen von Benutzerdaten.

1.1 - Authentication

Anweisungen zur API-Authentifizierung.

Unsere API unterstützt zwei Arten der Authentifizierung. API-Schlüssel sind einfach und unkompliziert zu verwenden, aber auch weniger sicher, da sie von Man-in-the-Middle-Angriffen betroffen sein können. Der sicherere Ansatz ist die Verwendung von OAuth mit Client Credential Flow. Auf diese Weise können wir Ihnen eine Identität bereitstellen oder auch Ihren Identitätsanbieter verwenden.

API Key

Um einen API-Schlüssel verwenden zu können, müssen wir diese Funktion in Ihrem Tenant aktivieren. Der bereitgestellte Schlüssel muss mit jeder Anfrage unter Verwendung des X-API-KEY-Headers gesendet werden.

curl --request GET \
  --url https://api.omniac.de/v1/tenant \
  --header 'X-API-KEY: <<API KEY>>'

OAuth Client Credential

Bald verfügbar

1.2 - Grundlegende Datenstruktur

Informationen zur Datenstruktur und zugehörigen Terminologie.

Hier finden Sie eine kurze einführende Darstellung der Datenstruktur. Jeder Tenant verfügt über mehrere Profile, innerhalb eines Profils gibt es eine Liste mit Attributen und Alerts.

- * tenant
  |- settings
  |
  |- profiles
     |- profile
     |  |- alerts
     |  |- attributes
     |
     |- profile
     |  |- alerts
     |  |- attributes

1.3 - OpenAPI Generator

Anweisungen zur Nutzung eines OpenAPI-Generators.

OpenAPI Generator

Wir empfehlen, den offiziellen OpenAPI Generator zur Generierung des Client-Codes zu verwenden. Der Generator ist unter OpenAPI Generator zu finden. Er bietet verschiedene Optionen zur Generierung von Client-Bibliotheken in unterschiedlichen Programmiersprachen. Er generiert Code auf Basis der OpenAPI-Spezifikation, wie z.B. Funktionen zum Aufrufen der Endpunkte und Typen für die Request- und Response-Bodies.

Client Generation Schritte

  1. Herunterladen der OpenAPI Spezifikation: Laden Sie die OpenAPI-Spezifikationsdatei für omniac Business herunter. Diese Datei liegt im YAML-Format vor und beschreibt die API-Endpunkte, Anfrageparameter und Antwortstrukturen.
  2. Installieren des OpenAPI Generators: Falls noch nicht geschehen, installieren Sie das OpenAPI Generator CLI-Tool. Installationsanweisungen finden Sie in der OpenAPI Generator-Dokumentation.
  3. Den Client generieren: Verwenden Sie die OpenAPI Generator CLI, um den Client-Code zu generieren. Der Befehl sieht in der Regel wie folgt aus:
openapi-generator-cli generate -i path/to/openapi.yaml -g <language> -o path/to/output/directory

Ersetzen Sie <language> durch die gewünschte Programmiersprache (z. B. python, java, javascript usw.) und geben Sie den Pfad zur OpenAPI-Spezifikationsdatei und das Ausgabeverzeichnis an, in dem der generierte Client-Code gespeichert werden soll.

1.4 - Push-Benachrichtigungen

Wie man Benachrichtigungen über eine Push-API erhält.

Um noch schneller benachrichtigt zu werden, bieten wir eine Push-API für neue Alerts an. Sobald ein Datenleck-Vorfall gefunden wird, veröffentlichen wir die Warnmeldung in Ihrem System. Dies geschieht über einen HTTP-Aufruf. Die Zustellung wird auf unserer Seite als abgeschlossen markiert, sobald Ihre API einen 2xx-HTTP-Statuscode zurückgibt.

Um diese Funktion nutzen zu können, müssen Sie sich mit uns in Verbindung setzen, damit wir die Funktion für Ihren Tenant aktivieren können.

Der Payload sieht wie folgt aus:

{
  "_id": {
    "$oid": "REDACTED"
  },
  "is_read": false,
  "profile_id": {
    "$oid": "REDACTED"
  },
  "enrollment_id": {
    "$oid": "REDACTED"
  },
  "enrollment_provider": "",
  "alert_id": "REDACTED",
  "client_id": "REDACTED",
  "alert_flow": "retrospective",
  "masked_values": [
    {
      "name": "password",
      "value": "",
      "passwordcleartext": false
    },
    {
      "name": "email",
      "value": "t******@ex*****e.com",
      "passwordcleartext": null
    },
    {
      "name": "domain",
      "value": "ex*****e.com",
      "passwordcleartext": null
    },
    {
      "name": "network_ip",
      "value": "12*****.1",
      "passwordcleartext": null
    },
    {
      "name": "username",
      "value": "********",
      "passwordcleartext": null
    }
  ],
  "password_last_characters": "",
  "breach_category_locale": "Spiele",
  "description_type": "code_standard",
  "recommendation": "Ändere dein Passwort für das betroffene Kundenkonto. Überprüfe schnell alle anderen Dienste, bei denen du das gleiche oder ein ähnliches Passwort benutzt. Sei aufmerksam in Bezug auf ungewöhnliche Aktivitäten rund um deine Identität",
  "description": "Deine Daten wurden am DATUM im WEBSEITE-Datenleck veröffentlicht.",
  "name": "WEBSEITE",
  "source": "darkweb",
  "breach_record_exposure_score": "Very Low",
  "date_register": {
    "$date": "2014-01-30T00:00:00.000Z"
  },
  "creation_date": {
    "$date": "2025-09-30T12:15:13.883Z"
  },
  "done": false,
  "done_date": {
    "$date": {
      "$numberLong": "-62135596800000"
    }
  },
  "type": "darkweb"
}

1.5 - Verschlüsselung im Client

Client seitige Normalisierung, Verschlüsselung und Hashing

Neben der Möglichkeit, die zu überwachenden Daten im Klartext an omniac Business zu senden, bieten wir auch an, die Daten bereits normalisiert, verschlüsselt und gehasht zu empfangen. Letzteres ist auch der von uns empfohlene Weg, da so die persönlichen Attribute Ihrer Nutzer nie im Klartext Ihren Firmenkontext verlassen. Die Verarbeitungsschritte, die dafür notwendig sind, müssen identisch mit denen sein, die wir durchführen, bevor wir die Daten zum Durchsuchen unserer Datenleck-Datenbank verwenden. Im Folgenden wird dieses Vorgehen kurz erläutert.

Tenant abrufen

In Ihrem Tenant finden Sie alle notwendigen Informationen zur Normalisierung, Verschlüsselung und zum Hashing. Im Feld “available_attributes” finden Sie die Normalisierungsregeln, im Feld “hash_algorithm” die zu verwendende Hash-Funktion und im Feld “encryption_key” den Public Key, um die Daten zu verschlüsseln. Jeder dieser Schritte wird nun kurz erläutert.

Beispiel: E-Mail

Der Schritt der Normalisierung muss zu Beginn und vor jeder weiteren Verarbeitung durchgeführt werden. Wir betrachten nun das Beispiel der E-Mail (zu finden in den “available_attributes” des Tenants):

{
    "key": "email",
    "encrypted": true,
    "split": false,
    "normalize": [
        "DeleteQuotationMarks",
        "DeleteTrailingComma",
        "UnicodeNormalization",
        "Strip",
        "Lowercase"
    ],
    "mask": {
        "task": "email",
        "begin": 0,
        "end": 0
    }
},

Alle folgenden Schritte werden auf der normalisierten Version der E-Mail vorgenommen. Als Nächstes folgt das Hashing. Hierzu wird im Tenant der Algorithmus vorgegeben, der aktuell jedoch immer SHA-256 ist. Die Verschlüsselung ist nicht bei jedem Attribut benötigt (siehe boolean Feld encrypted). Wenn encrypted=true ist, wird der PKCS1 Algorithmus genutzt. Hier eine Beispielimplementierung in Go:

func EncryptWithPublicKey(pubKey string, data string) (string, error) {
	publicKeyBytes, err := base64.StdEncoding.DecodeString(pubKey)
	if err != nil {
		return "", errors.New("failed to decode public key: " + err.Error())
	}

	rsaPublicKey, err := ParseRsaPublicKeyFromPemStr(string(publicKeyBytes))
	if err != nil {
		return "", errors.New("ParseRsaPublicKey: " + err.Error())
	}
	rng := rand.Reader
    ciphertext, err := rsa.EncryptPKCS1v15(rng, rsaPublicKey, []byte(data))
	if err != nil {
		return "", errors.New("failed to encrypt data: " + err.Error())
	}

	// Encode the encrypted data to base64 for easy transmission or storage
	return base64.StdEncoding.EncodeToString(ciphertext), nil
}

Das masking liegt in der Hand der Kunden und die übermittelten Werte stellen nur einen Vorschlag dar. Hier geht es darum, wie die Werte maskiert trotzdem gespeichert werden um eine ungefähre Zuordnung für den Nutzer zu ermöglichen. So kann zum Beispiel die mail “test@example.com” als “te*****@**ple.com” übergeben werden.

Beispiel: Name (split Attribut)

Ist der Parameter “split” in der AttributConfig gesetzt, erwartet omniac Business, dass nach der Normalisierung die Werte an Leerzeichen getrennt und die entstandenen Teile einzeln erneut Normalisiert und Gehashed werden. Verschlüsselt wird trotzdem der gesamte Wert. Abschließend werden die gehashten Werte als string mit Kommas verbunden an omniac Business übermittelt. Es folgt ein Beispiel:

{
    "key": "name",
    "encrypted": true,
    "split": true,
    "normalize": [
        "DeleteQuotationMarks",
        "DeleteTrailingComma",
        "ReplaceSymbols",
        "DeleteConsecutiveSpaces",
        "UnicodeNormalization",
        "Strip",
        "Lowercase"
    ],
    "mask": {
        "task": "",
        "begin": 0,
        "end": 0
    }
},

Sollte beispielsweise der Name gemonitored werden, sind folgende Schritte notwendig, da split=true ist. Name Beispiel: “Max Mustermann”

  1. Normaliserung des gesamten Strings (“max mustermann”)
  2. Verschlüsselung des normalisierten Strings (“Q2CWI6xZ6r2QsS/tJCARqzFWEXh+aeRuClgaX4AzMrNAXrgyQcfq6/lYsCGvSPVa1jTWF7zd4fmi2AMh3DbirRNpfCJNNZcW2mE1Iw0EhilpYen6nYAMPtxb5zHhsb2DfaKr0qOFal1zIjDM+KiAbLaiOF+wTajGmH/3Bt2rwvK30/qDta3u3oplKzLVNqaoWpqGqiv0cKx9ytday8YqxqbqNcGZf1ztZVUAxkS4M0UHsVHVnHDK6ADcZoz2scdJU9nwipb0C2dXGePlE/hBBttkzq6lR2vExfIbjTQ+QEhzQiUdvz9WeuckHLRG8jGhMnSpIUZ9Pt/w2H1qAoEN0A==”)
  3. Aufteilen des Strings an den Leerzeichen ([“max”, “mustermann”])
  4. Normalisierung der Teile ([“max”, “mustermann”])
  5. Hashing der Teile ([“9baf3a40312f39849f46dad1040f2f039f1cffa1238c41e9db675315cfad39b6”, “e32a370b7912ad78cc6a88fda605a5b3657e9c3b164cee669364aaf3f8cdbb36”])
  6. Zusammenführen der gehashten Teile als String getrennt mit Kommas (“9baf3a40312f39849f46dad1040f2f039f1cffa1238c41e9db675315cfad39b6,e32a370b7912ad78cc6a88fda605a5b3657e9c3b164cee669364aaf3f8cdbb36”)

Senden der Attribute

Während ein normaler PUT /v1/profiles/:profile_id/attributes call body so aussieht:

[
     {
        "type": {
            "key": "name"
        },
        "value": "Max Mustermann",
    },
    {
        "type": {
            "key": "email"
        },
        "value": "test@example.com",
    },
]

erwarten wir folgendes Format für im Client gehashte und verschlüsselte Werte:

[
     {
        "type": {
            "key": "name"
        },
        "value": "M** ******mann",
        "hashed": "9baf3a40312f39849f46dad1040f2f039f1cffa1238c41e9db675315cfad39b6,e32a370b7912ad78cc6a88fda605a5b3657e9c3b164cee669364aaf3f8cdbb36",
        "encrypted": "Q2CWI6xZ6r2QsS/tJCARqzFWEXh+aeRuClgaX4AzMrNAXrgyQcfq6/lYsCGvSPVa1jTWF7zd4fmi2AMh3DbirRNpfCJNNZcW2mE1Iw0EhilpYen6nYAMPtxb5zHhsb2DfaKr0qOFal1zIjDM+KiAbLaiOF+wTajGmH/3Bt2rwvK30/qDta3u3oplKzLVNqaoWpqGqiv0cKx9ytday8YqxqbqNcGZf1ztZVUAxkS4M0UHsVHVnHDK6ADcZoz2scdJU9nwipb0C2dXGePlE/hBBttkzq6lR2vExfIbjTQ+QEhzQiUdvz9WeuckHLRG8jGhMnSpIUZ9Pt/w2H1qAoEN0A=="
    },
    {
        "type": {
            "key": "email"
        },
        "value": "te*****@**ple.com",
        "hashed": "973dfe463ec85785f5f95af5ba3906eedb2d931c24e69824a89ea65dba4e813b",
        "encrypted": "K/QKpKzdLLGRSayMrqPFqpBCN/vH6fDKWltqNqX1E0ZBLZQEya6rLqg8VTiomyC3hDnp3d+YFHYwXyFpCRjIXQ0uXA8Yz2fZWHnYdLVv5ua2gYAC9huCJmtM89wYBLINPq47gERwHUeiSzVxNk3D6XvwgvGQXd+N+y/A4XC+mhhe603CrC6lzY0N2e7QyQK5YBni9mfr0S+lMVN6CpGqBlnucKGaVXdPn9fBmwWvW3pkA4uoEhRQruD9fdIBFrOy388ctRtrmHFVlP5IWkwXxXas2CpLCarapgULJcO9pG6kG0RqE+NAiKgsZ2Jw3PA0ZLqjp0sIXH3xTzLPNZJ7xQ=="
    },
]

Nun sind die Attribute, wie in der Version, in der omniac Business diese Schritte übernimmt, bei uns abgelegt und werden überwacht.

2 - Datenstrukturen

Diese Sektion beschreibt die Datenstruktur innerhalb der Anwendung.

2.1 - Alerts

Datentyp Alert

Alerts sind Warnmeldungen, die von omniac Business generiert werden, wenn Datenleck-Vorfälle für bestimmte Attribute festgestellt werden. Diese Alerts sind für die Aufrechterhaltung der Sicherheit und Privatsphäre der Daten der Benutzer von entscheidender Bedeutung. Jeder Alert enthält Details zum Vorfall, einschließlich des betroffenen Attribut, der Quelle, Zeitpunkt des Vorfalls, einer Klassifizierung zur Kritikalität, einer kurzen Standardbeschreibung des Vorfalls und einer Handlungsempfehlung. Je nachdem, welche Details benötigt werden, kann der Alert-Payload angepasst werden.

Wir stellen diese Alerts über REST im JSON-Format bereit. Sobald wir ein Datenleck-Vorfall erkennen, lösen wir den im Tenant konfigurierten Endpunkt aus.

Ein Beispiel-Alert sieht wie folgt aus:

{
    "alert_id": "685e5c371f317d8df6c618a3",
    "alert_flow": "retrospective",
    "masked_values": [
        {
            "name": "bank_account",
            "value": "could not resolve data"
        },
        {
            "name": "credit_card",
            "value": "could not resolve data"
        },
        {
            "name": "iban",
            "value": "could not resolve data"
        },
        {
            "name": "nid",
            "value": "could not resolve data"
        },
        {
            "name": "passport",
            "value": "could not resolve data"
        },
        {
            "name": "driver_license",
            "value": "could not resolve data"
        }
    ],
    "password_last_characters": "",
    "breach_category_locale": "",
    "description_type": "",
    "recommendation": "If the website has customer service or privacy officer contact information, request that any of your personal data be removed immediately.",
    "description": "On 05/24/2023, we discovered this identity information including your names, surnames, emails and addresses that we believe belongs to you from sec.gov/Archives/edgar/Feed/2002/QTR3",
    "name": "sec.gov",
    "source": "",
    "type": "surface",
    "breach_record_exposure_score": "Medium",
    "date_register": "2023-05-18T09:10:36Z",
    "creation_date": "2025-06-27T08:54:15Z",
    "done": false,
    "done_date": "0001-01-01T00:00:00Z"
}

2.2 - Attribute

Datentyp Attribut

Attribute werden verwendet, um verschiedene personenbezogene Daten eines Benutzers anzulegen und zu überwachen. Jedes angelegte Attribut wird maskiert, gehasht und verschlüsselt gespeichert, um Datenschutz und Sicherheit zu gewährleisten. Es stehen bis zu 39 verschiedene Attribute zur Verfügung – eine detaillierte Liste finden Sie weiter unten. Die Pflege der Attribute erfolgt über den PUT-Endpunkt /attributes. Dabei werden alle Attribute durch die angegebenen ersetzt. Achten Sie daher darauf, auch die bestehenden Attribute mit anzugeben. Auf bestehende Attribute kann über den GET-Endpunkt /profile zugegriffen werden.

  • Name
  • Nachname
  • Mädchenname der Mutter
  • Name der Mutter
  • E-Mail (bis zu 10 Werte verfügbar)
  • Festnetz und Mobilfunknummer (bis zu 10 Werte verfügbar)
  • Adresse: (bis zu 10 Werte verfügbar)
    • Straßenname
    • Stadt
    • Postleitzahl
    • Bundesland
  • Geburtsdatum
  • Kreditkartennummer (bis zu 10 Werte verfügbar)
  • IP-Adresse (bis zu 10 Werte verfügbar)
  • Loyalty Program Nummer (bis zu 10 Werte verfügbar)
  • Krankenversicherungsnummer (bis zu 10 Werte verfügbar)
  • National Health Service Number (nur UK)
  • Versicherungsnummer (bis zu 10 Werte verfügbar)
  • Username (jeglicher Plattformen, bis zu 10 Werte verfügbar)
  • Gamertag (bis zu 10 Werte verfügbar)
  • Online Konten (Youtube, Facebook, Instagram, Google etc.- ca. 20 unterschiedliche Plattformen)
  • Bankkontonummer (bis zu 10 Werte verfügbar)
  • IBAN (bis zu 10 Werte verfügbar)
  • Führerscheinnummer (bis zu 10 Werte verfügbar)
  • Personalausweisnummer (bis zu 10 Werte verfügbar)
  • Reisepassnummer (bis zu 10 Werte verfügbar)
  • Sozialversicherungsnummer
  • Steueridentifikationsnummer
  • Visum Nummer (bis zu 10 Werte verfügbar)
  • Crypto Wallet (bis zu 10 Werte verfügbar)

2.3 - Profile

Datentyp Profile

Ein Profil enthält alle Informationen zu einem bestimmten Benutzer innerhalb Ihres Tenants. Dieses Profil kombiniert eine Reihe von Attributen, die für einen Benutzer gespeichert wurden, und die ausgelösten Alerts bei festgestellten Datenleck-Vorfällen.

Das Erstellen eines Profils ist so einfach wie das Senden einer POST-Anfrage an den Profil-Endpunkt (/v1/profiles). Der gleiche Endpunkt akzeptiert auch Anfragen mit einer Profil-ID (/v1/profiles/{profileID}) mit den folgenden Methoden:

  • GET zum Abrufen eines Profils,
  • DELETE zum Entfernen eines Profils und
  • PUT zum Speichern neuer Attribute.

Ausführliche Informationen zu Anfragen und Antworten finden Sie in der OpenAPI-Spezifikation.

Sie können auch alle zugehörigen Profile für Ihren Tenant anfordern, indem Sie eine GET-Anfrage ohne Angabe der Profil-ID senden.

2.4 - Tenants

Datentyp Tenant

Tenants sind einzelne Kunden oder Organisationen, die den omniac Business-Dienst nutzen. Jeder Tenant verfügt über eigene Benutzer, Daten und Konfigurationen, was eine maßgeschneiderte Sicherheitsüberwachung und -verwaltung ermöglicht. Der Zugriff auf Daten anderer Tenants ist nicht möglich, sodass die Informationen jedes Tenants privat und sicher bleiben.

Konfiguration

Zunächst wird Ihnen von omniac Business ein Tenant zur Verfügung gestellt. Sie oder ein Vertreter von omniac Business können den Tenant dann nach Ihren Bedürfnissen konfigurieren. Die Konfiguration umfasst:

  • Contact: Die Kontaktinformationen (Name, E-Mail-Adresse) für eine oder mehrere Kontaktpersonen in Ihrer Organisation.
  • Push-Endpoint: Die URL, an die omniac Business Benachrichtigungen über Datenlecks und Sicherheitswarnungen sendet.
  • Hash-Algorithm: Omniac Business unterstützt Hashing entweder auf Client- oder auf Serverseite. Sie können den Algorithmus auswählen, der für das Hashing Ihrer Daten verwendet wird. Aus Sicherheitsgründen empfehlen wir dringend serverseitiges Hashing. Der Standardalgorithmus ist SHA-256.
  • Encryption Key: Wenn Sie Ihre Daten verschlüsseln möchten, stellen wir Ihnen diesen Encryption Key bereit. Dieser Schlüssel wird verwendet, um Ihre Daten zu verschlüsseln, bevor sie zur Überwachung an omniac Business gesendet werden. Bitte nutzen Sie den RSA PKCS#1 v1.5 Algorithmus zur Verschlüsselung.
  • Zulässige ACLs: Sie können festlegen, welche Zugriffskontrolllisten (ACLs) für Ihren Tenant zulässig sind. Jede ACL-Konfiguration besteht aus einem Namen und einer ACL-IP-Adresse. Auf diese Weise können Sie steuern, welche IP-Adressen auf die Daten und Dienste Ihres Tenants zugreifen können.
  • Verfügbare Attribute: Je nach Ihrem Vertrag handelt es sich hierbei um eine Liste von Attributen, die omniac Business für Ihren Tenant überwacht. Jeder Kunde/Mitarbeiter kann dann 0-n Attribute überwachen. Die Attribute werden von omniac Business definiert und gepflegt.
  • Ratelimits: Legt fest, wie viele Anfragen pro Zeit vom omniac Business-Dienst für Ihren Tenant akzeptiert werden. Dies dient dazu, Missbrauch zu verhindern und eine faire Nutzung des Dienstes zu gewährleisten. Die Ratenbegrenzungen werden von omniac Business gepflegt.

Authentifizierung

Um auf den omniac Business-Dienst zugreifen zu können, muss sich jeder Tenant mit einem eindeutigen API-Schlüssel authentifizieren. Dieser Schlüssel wird von omniac Business bereitgestellt und sollte sicher aufbewahrt werden. Der API-Schlüssel wird verwendet, um den Tenant zu identifizieren und den Zugriff auf den Dienst zu autorisieren.

3 - Beispiele

Hier finden Sie einige Beispielimplementierungen für omniac Business.

In diesem Abschnitt finden Sie einige Beispielimplementierungen. Wir bieten Beispiele für die Verwendung unserer API und auch für die Implementierung der Datenverarbeitung wie Hashing und Verschlüsselung.

3.1 - Beispiel Golang

Beispielimplementierung einer Golang-Anwendung zur Nutzung der omniac Business API

Einführung und Projekteinrichtung

Go (Golang) ist eine statisch typisierte, kompilierte Programmiersprache, die von Google entwickelt wurde und für ihre Einfachheit, Effizienz und hervorragende Unterstützung von Parallelität bekannt ist, wodurch sie sich ideal für die Erstellung skalierbarer Webdienste, APIs und Microservices eignet. Um Projektabhängigkeiten in Go zu verwalten, verwenden Sie Go-Module. Sie können ein neues Go-Modul in Ihrem Projektverzeichnis initialisieren, indem Sie den Befehl go mod init <Modulname> ausführen, wobei <Modulname> in der Regel die URL Ihres Repositorys ist (z. B. github.com/Benutzername/Projekt). Dadurch wird eine go.mod-Datei erstellt, die Ihre Abhängigkeiten verfolgt. Wenn Sie Pakete importieren und go mod tidy ausführen, lädt Go automatisch die erforderlichen Abhängigkeiten herunter und verwaltet sie. Das Modulsystem von Go gewährleistet reproduzierbare Builds und eine ordnungsgemäße Versionsverwaltung. Sie können Ihr Projekt mit go build erstellen und es direkt mit go run main.go ausführen. Dieser Ansatz sorgt für eine gute Organisation Ihrer Projekte und gewährleistet eine konsistente Abhängigkeitsverwaltung in verschiedenen Umgebungen.

Voraussetzungen

Wir empfehlen die Verwendung einer Unix-basierten Entwicklungsumgebung. Dies ist nicht nur mit Linux oder macOS möglich, sondern auch durch die Installation des Linux-Subsystems für Windows. Wenn Sie ein normales Windows-System verwenden, müssen Sie möglicherweise bestimmte Schritte anpassen.

Generieren des API-Clients

Für golang empfehlen wir die Verwendung von ogen, um den erforderlichen Code für die Interaktion mit der API zu generieren. Dies gewährleistet Sicherheit und sorgt dafür, dass kritische Fehler so schnell wie möglich behoben werden.

mkdir omniac-client
cd omniac-client
go mod init github.com/yourusername/omniac-client

Fügen Sie jetzt folgende Zeile in die generierte go.mod Datei ein, um die Abhängigkeit zu ogen hinzuzufügen:

module o4b_client_test

go 1.25.3

tool github.com/ogen-go/ogen/cmd/ogen
require (
    [...]
)

Führen Sie nun go mod tidy aus und legen anschließend eine generate.go Datei mit folgendem Inhalt an:

package main

//go:generate go tool ogen --target pkg/o4b --package o4b --clean openapi.yaml

Wenn Sie jetzt die omniac Business OpenAPI-Spezifikation als openapi.yaml in ihrer Project Root ablegen, können Sie den API-Client mit folgendem Befehl generieren:

go generate

Authentication einrichten

Legen Sie nun eine main.go Datei an und importieren Sie den generierten Code, um den Client zu konfigurieren. Sie benötigen dazu die URL sowie Ihren API-Schlüssel. Dieser Code muss vor jedem API-Aufruf ausgeführt werden.

package main

import (
	"context"
	omniac "o4b_client_test/pkg/o4b"
)

type APIKeyProvider struct {
	ApiKey string
}

func (a APIKeyProvider) ApiKeyAuth(ctx context.Context, operationName omniac.OperationName) (omniac.ApiKeyAuth, error) {
	return omniac.ApiKeyAuth{APIKey: a.ApiKey}, nil
}

func main() {
	sec := APIKeyProvider{
		ApiKey: "your_api_key_here",
	}
	client, err := omniac.NewClient("https://api.omniac.de", sec)
	if err != nil {
		panic(err)
	}

}

Tenant info abrufen

Jetzt können Sie eine API-Instanz der TenantAPI initialisieren. Verwenden Sie die Funktion „get_tenant“ Ihres api_client, um Informationen über Ihren Tenant abzurufen.

[...]

ctx := context.Background()
tenantRes, err := client.GetTenant(ctx)
if err != nil {
    panic(err)
}

switch res := tenantRes.(type) {
case *omniac.Tenant:
    fmt.Println(res)
case *omniac.GetTenantBadRequest:
    fmt.Println("Bad Request:", res)
case *omniac.GetTenantUnauthorized:
    fmt.Println("Unauthorized:", res)
case *omniac.GetTenantInternalServerError:
    fmt.Println("Internal Server Error:", res)
default:
    fmt.Println("Unexpected response type")
}

Profile zum Tenant hinzufügen

Um die Überwachung von Attributen zu starten und Benachrichtigungen zu erhalten, müssen Sie einen Benutzer für Ihren tenant konfigurieren. Nachdem Sie das Profil erfolgreich erstellt haben, können Sie mit dem Hinzufügen von Attributen beginnen.

[...]
profileRes, err := client.CreateProfile(ctx, &omniac.ProfileCreateRequest{
    UserLanguage: omniac.NewOptString("de"),
    Name:         "test",
})
if err != nil {
    panic(err)
}

var profile *omniac.Profile
switch res := profileRes.(type) {
case *omniac.Profile:
    profile = res
    fmt.Println(res)
case *omniac.CreateProfileBadRequest:
    fmt.Println("Bad Request:", res)
case *omniac.CreateProfileUnauthorized:
    fmt.Println("Unauthorized:", res)
case *omniac.CreateProfileInternalServerError:
    fmt.Println("Internal Server Error:", res)
default:
    fmt.Println("Unexpected response type")
}

attributeRes, err := client.ReplaceAttributes(ctx, []omniac.AttributeCreateRequest{
    {
        Type: "email",
        Value: "test@example.com",
    }},
    omniac.ReplaceAttributesParams{
        ProfileID: profile.ID,
    })
if err != nil {
    panic(err)
}

switch res := attributeRes.(type) {
case *omniac.ReplaceAttributesOK:
    fmt.Println(res)
case *omniac.ReplaceAttributesBadRequest:
    fmt.Println("Bad Request:", res)
case *omniac.ReplaceAttributesUnauthorized:
    fmt.Println("Unauthorized:", res)
case *omniac.ReplaceAttributesInternalServerError:
    fmt.Println("Internal Server Error:", res)
default:
    fmt.Println("Unexpected response type")
}

Mehrere Profile als Batch anlegen

Neben der Möglichkeit individuelle Profile anzulegen, bietet omniac Business auch an bis zu 500 Profile gleichzeitig mit Attributen anzulegen.

	batchProfileRes, err := client.CreateProfiles(ctx, []omniac.ProfileCreateBatchRequest{
		{
			UserLanguage: omniac.NewOptString("de"),
			Name:         "batch_test_1",
			Attributes: []omniac.AttributeCreateRequest{
				{
					Type:  "email",
					Value: "test@example.com",
				},
			},
		},
		{
			UserLanguage: omniac.NewOptString("en"),
			Name:         "batch_test_2",
			Attributes: []omniac.AttributeCreateRequest{
				{
					Type:  "email",
					Value: "test2@example.com",
				},
			},
		},
	})

	if err != nil {
		panic(err)
	}

	switch res := batchProfileRes.(type) {
	case *omniac.CreateProfilesCreated:
		fmt.Println(res)
	case *omniac.CreateProfilesBadRequest:
		fmt.Println("Bad Request:", res)
	case *omniac.CreateProfilesUnauthorized:
		fmt.Println("Unauthorized:", res)
	case *omniac.CreateProfilesInternalServerError:
		fmt.Println("Internal Server Error:", res)
	default:
		fmt.Println("Unexpected response type")
	}

Alerts abrufen

Nach einigen Minuten gehen Alerts ein, falls Lecks gefunden wurden. Sie können diese mit der Funktion „get_profile“ und Ihrer ProfileID abrufen. Mit den beiden Parametern nach der ProfileID können Sie neben den Alerts auch die Benutzerattribute (gehasht und verschlüsselt) abrufen.

[...]
alertRes, err := client.GetAlerts(ctx, omniac.GetAlertsParams{
    ProfileID: omniac.NewOptString(profile.ID),
})
if err != nil {
    panic(err)
}

switch res := alertRes.(type) {
case *omniac.GetAlertsOK:
    fmt.Println(res.Data)
case *omniac.GetAlertsBadRequest:
    fmt.Println("Bad Request:", res)
case *omniac.GetAlertsUnauthorized:
    fmt.Println("Unauthorized:", res)
case *omniac.GetAlertsInternalServerError:
    fmt.Println("Internal Server Error:", res)
default:
    fmt.Println("Unexpected response type")
}

Push-Benachrichtigungs-Endpunkt bereitstellen

Um Sie noch schneller zu benachrichtigen, bieten wir eine Push-API für neue Benachrichtigungen an. Sobald etwas gefunden wird, veröffentlichen wir die Benachrichtigung in Ihrem System. Dies geschieht über einen HTTP-Aufruf. Die Zustellung wird auf unserer Seite als abgeschlossen markiert, sobald Ihre API einen 2xx-HTTP-Statuscode zurückgibt.

Um diese Funktion nutzen zu können, müssen Sie sich mit uns in Verbindung setzen, damit wir die Funktion für Ihren Tenant aktivieren können.

3.2 - Beispiel Python

Beispielimplementierung einer Python-Anwendung zur Nutzung der omniac Business API

Einführung und Projekteinrichtung

Python ist eine vielseitige, weit verbreitete Programmiersprache, die für ihre Einfachheit und umfangreichen Bibliotheken geschätzt wird und sich ideal für Webentwicklung, Datenanalyse und Automatisierung eignet. Um projektspezifische Abhängigkeiten zu verwalten und Konflikte zu vermeiden, empfiehlt es sich, eine virtuelle Umgebung zu verwenden. Sie können eine solche Umgebung in Ihrem Projektverzeichnis erstellen, indem Sie den Terminalbefehl python -m venv .venv ausführen, wobei .venv der Name Ihres Umgebungsordners ist. Nach der Erstellung müssen Sie diese aktivieren. Unter Windows verwenden Sie „.venv\Scripts\activate“ und unter macOS oder Linux „source .venv/bin/activate“. Nach der Aktivierung ändert sich Ihre Eingabeaufforderung und zeigt den Namen der Umgebung an. Alle Pakete, die Sie mit „pip“ installieren, werden für dieses bestimmte Projekt isoliert. Wenn Sie fertig sind, geben Sie einfach „deactivate“ ein, um zu Ihrem globalen Python-Kontext zurückzukehren. Dieser Prozess sorgt dafür, dass Ihre Projekte übersichtlich und reproduzierbar bleiben.

Empfohlene Entwicklungsumgebung

VSCodium, die Open-Source-Version von VS Code, ist eine ausgezeichnete Wahl für die Python-Entwicklung. Nach der Installation müssen Sie zunächst die offizielle Python-Erweiterung aus dem Marktplatz hinzufügen, um leistungsstarke Funktionen wie IntelliSense (Code-Vervollständigung), Linting (Fehlerprüfung) und Debugging freizuschalten. Öffnen Sie Ihren Projektordner in Codium (Datei > Ordner öffnen...). Der Editor erkennt Ihre virtuelle Umgebung oft automatisch, aber Sie können sie auch manuell auswählen, indem Sie die Befehlspalette (Strg+Umschalt+P) öffnen, nach „Python: Interpreter auswählen” suchen und die Python-Ausführungsdatei in Ihrem myenv-Ordner auswählen. Dadurch wird Codium korrekt für die Verwendung der isolierten Pakete Ihres Projekts konfiguriert. Anschließend können Sie das integrierte Terminal (Strg+) verwenden, um Ihre Skripte auszuführen, neue Pakete mit pip zu installieren und die Versionskontrolle mit Git zu verwalten, ohne den Editor verlassen zu müssen. Mit der Möglichkeit, Breakpoints zu setzen und Ihren Code mithilfe des Fensters „Ausführen und Debuggen“ schrittweise durchzugehen, bietet Codium eine umfassende und optimierte Umgebung für die Erstellung und das Testen Ihres Python-Tools von Anfang bis Ende.

Vorraussetzungen

Wir empfehlen dringend die Verwendung einer Unix-basierten Entwicklungsumgebung. Dies ist nicht nur mit Linux oder macOS möglich, sondern auch durch die Installation des Linux-Subsystems für Windows. Wenn Sie ein reines Windows-System verwenden, müssen Sie möglicherweise bestimmte Schritte anpassen.

Venv erstellen

Wir werden ein venv verwenden. Dazu führen wir einfach die folgenden Befehle aus.

python3 -m venv .venv
source .venv/bin/activate

Generieren des API-Clients

Wie in unserer Dokumentation empfohlen, verwenden wir den openapi-generator, um den erforderlichen Code für die Interaktion mit der API zu generieren. Dies gewährleistet Sicherheit und sorgt dafür, dass kritische Fehler so schnell wie möglich behoben werden.

mkdir api
openapi-generator-cli generate -i openapi.yaml -g python -o /api
pip install ./api
cd ..
touch main.py

Mit Ihrer neu erstellten client.py Datei können Sie nun den generierten Code importieren und den Client konfigurieren. Sie benötigen dazu die URL sowie Ihren API-Schlüssel. Dieser Code muss vor jedem API-Aufruf ausgeführt werden.

import openapi_client as omniac

configuration = omniac.Configuration(
    host = "https://api.omniac.de"
)
configuration.api_key["ApiKeyAuth"] = "YOUR_API_KEY_GOES_HERE"

Tenant info abrufen

Jetzt können Sie eine API-Instanz der TenantApi initialisieren. Verwenden Sie die Funktion getTenant Ihres API-Clients, um Informationen über Ihren Tenant abzurufen.

import openapi_client as omniac

[...]
with omniac.ApiClient(configuration) as api_client:
    api_instance = omniac.TenantApi(api_client)
try:
    tenant = api_instance.get_tenant()
    print(tenant)
except Exception as e:
    print(f"Error: {e}")

Profile zum Tenant hinzufügen

Um die Überwachung von Attributen zu starten und Alerts zu erhalten, müssen Sie einen Benutzer für Ihren Tenant konfigurieren. Nachdem Sie das Profil erfolgreich erstellt haben, können Sie mit dem Hinzufügen von Attributen beginnen.

import openapi_client as omniac

[...]
with omniac.ApiClient(configuration) as api_client:
    api_instance = omniac.ProfileApi(api_client)
    newProfile = omniac.ProfileCreateRequest(
        name="test",
        user_language="de",
    )
try:
    profile = api_instance.create_profile(newProfile)

    print(profile.id)
    
    api_response = api_instance.replace_attributes(profile.id, [
        omniac.AttributeCreateRequest(
            type="email",
            value="test@example.com"
        )
    ])
    print(api_response)
except Exception as e:
    print(f"Error: {e}")

Mehrere Profile als Batch anlegen

Neben der Möglichkeit individuelle Profile anzulegen, bietet omniac Business auch an bis zu 500 Profile gleichzeitig mit Attributen anzulegen.

import openapi_client as omniac

[...]

with omniac.ApiClient(configuration) as api_client:
    api_instance = omniac.ProfileApi(api_client)
    profile_create_batch_request = [omniac.ProfileCreateBatchRequest(
        name="Test1",
            user_language="de",
            attributes=[
                omniac.AttributeCreateRequest(
                    type="email",
                    value="test@example.com"
                )
            ]
    )]
    
try:
    profiles = api_instance.create_profiles(profile_create_batch_request)
    print(profiles)
except Exception as e:
    print(f"Error: {e}")

Alerts abrufen

Nach einigen Minuten gehen Alerts ein, falls Lecks gefunden wurden. Sie können diese mit der Funktion „get_profile“ und Ihrer ProfileID abrufen. Mit den beiden Parametern nach der ProfileID können Sie neben den Alerts auch die Benutzerattribute (gehasht und verschlüsselt) abrufen.

import openapi_client as omniac

[...]
with omniac.ApiClient(configuration) as api_client:
    api_instance = omniac.ProfileApi(api_client)
    try:
        profile = api_instance.get_profile("profileID", True, True)
        print(profile)
    except Exception as e:
        print(f"Error: {e}")

Push-Benachrichtigungs-Endpunkt bereitstellen

Um Sie noch schneller zu benachrichtigen, bieten wir eine Push-API für neue Benachrichtigungen an. Sobald etwas gefunden wird, veröffentlichen wir die Benachrichtigung in Ihrem System. Dies geschieht über einen HTTP-Aufruf. Die Zustellung wird auf unserer Seite als abgeschlossen markiert, sobald Ihre API einen 2xx-HTTP-Statuscode zurückgibt.

Um diese Funktion nutzen zu können, müssen Sie sich mit uns in Verbindung setzen, damit wir die Funktion für Ihren Tenant aktivieren können.

3.3 - Beispiel Java

Beispielimplementierung einer Java-Anwendung zur Nutzung der omniac Business API

Einführung und Projekteinrichtung

Java ist eine robuste, objektorientierte Programmiersprache, die für ihre Plattformunabhängigkeit und ihr starkes Typsystem bekannt ist und sich daher ideal für Unternehmensanwendungen, Webdienste und groß angelegte Systeme eignet. Um Projektabhängigkeiten zu verwalten und Prozesse effektiv zu erstellen, empfiehlt es sich, ein Build-Tool wie Maven oder Gradle zu verwenden. In dieser Anleitung verwenden wir Maven. Sie können ein neues Maven-Projekt erstellen, indem Sie in Ihrem Terminal mvn archetype:generate -DgroupId=com.example.omniac -DartifactId=omniac-client -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false ausführen. Dadurch wird eine Standard-Projektstruktur mit einer pom.xml-Datei für die Abhängigkeitsverwaltung erstellt. Navigieren Sie mit „cd omniac-client“ zu Ihrem Projektverzeichnis. Die Maven-Struktur speichert Ihren Quellcode in „src/main/java“ und Tests in „src/test/java“ und bietet so eine übersichtliche und gut organisierte Entwicklungsumgebung, die für IDEs und andere Entwickler leicht verständlich ist.

Empfehlung: IntelliJ IDEA für die Entwicklung

IntelliJ IDEA ist eine ausgezeichnete Wahl für die Java-Entwicklung und bietet viele Funktionen, die die Entwicklung erleichtern. Öffnen Sie nach der Installation Ihr Maven-Projekt, indem Sie „Datei > Öffnen“ auswählen und das Stammverzeichnis Ihres Projekts (in dem sich die Datei „pom.xml“ befindet) auswählen. IntelliJ erkennt automatisch die Maven-Projektstruktur und lädt die Abhängigkeiten herunter. Die IDE bietet eine hervorragende IntelliSense-Funktion (Code-Vervollständigung), integrierte Refactoring-Tools und umfassende Debugging-Funktionen. Sie können Ihre Anwendung direkt aus der IDE heraus mit der grünen Wiedergabetaste ausführen oder das integrierte Terminal (Alt+F12) verwenden, um Maven-Befehle wie mvn compile, mvn test oder mvn package auszuführen. Die integrierte Versionskontrolle erleichtert die Verwaltung Ihres Git-Repositorys. Mit Funktionen wie automatischen Importen, Codeformatierung und intelligenter Fehlererkennung bietet IntelliJ IDEA eine umfassende Entwicklungsumgebung für die effiziente Erstellung und das Testen Ihrer Java-Anwendung.

Vorraussetzungen

Wir empfehlen dringend die Verwendung einer Unix-basierten Entwicklungsumgebung. Dies ist nicht nur mit Linux oder macOS möglich, sondern auch durch die Installation des Linux-Subsystems für Windows. Wenn Sie ein reines Windows-System verwenden, müssen Sie möglicherweise bestimmte Schritte anpassen.

Maven Projekt erstellen

Wie erwähnt, verwenden wir Maven für das Abhängigkeitsmanagement. Wenn Sie das Projekt noch nicht erstellt haben, führen Sie die folgenden Befehle aus:

mvn archetype:generate -DgroupId=com.example.omniac -DartifactId=omniac-client -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
cd omniac-client

Generieren des API-Clients

Wie in unserer Dokumentation empfohlen, verwenden wir den openapi-generator, um den erforderlichen Code für die Interaktion mit der API zu generieren. Dies gewährleistet Sicherheit und unterbricht den Vorgang bei kritischen Fehlern so schnell wie möglich.

Fügen Sie zunächst das OpenAPI Generator Maven-Plugin zu Ihrer pom.xml hinzu:

<project>
    <!-- ... existing configuration ... -->
    
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.swagger</groupId>
            <artifactId>swagger-annotations</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.10.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.10.1</version>
        </dependency>
        <!-- Additional dependencies required by generated code -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.findbugs</groupId>
            <artifactId>jsr305</artifactId>
            <version>3.0.2</version>
        </dependency>
        <dependency>
            <groupId>javax.ws.rs</groupId>
            <artifactId>javax.ws.rs-api</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>logging-interceptor</artifactId>
            <version>4.10.0</version>
        </dependency>
        <dependency>
            <groupId>io.gsonfire</groupId>
            <artifactId>gson-fire</artifactId>
            <version>1.7.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
        <plugin>
            <groupId>org.openapitools</groupId>
            <artifactId>openapi-generator-maven-plugin</artifactId>
            <version>6.6.0</version>
            <executions>
            <execution>
                <goals>
                <goal>generate</goal>
                </goals>
                <configuration>
                <inputSpec>${project.basedir}/openapi.yaml</inputSpec>
                <generatorName>java</generatorName>
                <output>${project.basedir}/target/generated-sources</output>
                <apiPackage>com.example.omniac.api</apiPackage>
                <modelPackage>com.example.omniac.model</modelPackage>
                <generateSupportingFiles>true</generateSupportingFiles>
                <invokerPackage>com.example.omniac.client</invokerPackage>
                <configOptions>
                    <library>okhttp-gson</library>
                </configOptions>
                </configuration>
            </execution>
            </executions>
        </plugin>
        </plugins>
    </build>
</project>

Kopieren Sie anschließend die „openapi.yaml“ in das Projektverzeichnis und generieren Sie den Client:

mvn clean generate-sources

Erstellen Sie nun eine main-class, um den API-Client zu konfigurieren. Erstellen Sie src/main/java/com/example/omniac/OmniacClient.java:

package com.example.omniac;

import com.example.omniac.client.ApiClient;
import com.example.omniac.client.Configuration;

public class OmniacClient {
    private static ApiClient apiClient;
    
    public static void initializeClient(String apiKey) {
        apiClient = Configuration.getDefaultApiClient();
        apiClient.setBasePath("https://api.omniac.de");
        apiClient.setApiKey(apiKey);
    }
    
    public static ApiClient getApiClient() {
        return apiClient;
    }
}

Tenant info abrufen

Jetzt können Sie eine API-Instanz der TenantAPI initialisieren. Verwenden Sie die Funktion getTenant Ihres API-Clients, um Informationen über Ihren Tenant abzurufen.

package com.example.omniac;

import com.example.omniac.api.TenantApi;
import com.example.omniac.model.Tenant;

public class TenantExample {
    public static void main(String[] args) {
        // Initialize the client with your API key
        OmniacClient.initializeClient("YOUR_API_KEY_GOES_HERE");
        
        TenantApi tenantApi = new TenantApi(OmniacClient.getApiClient());
        
        try {
            Tenant tenant = tenantApi.getTenant();
            System.out.println(tenant);
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Profile zum Tenant hinzufügen

Um die Überwachung von Attributen zu starten und Alerts zu erhalten, müssen Sie einen Benutzer für Ihren Tenant konfigurieren. Nachdem Sie das Profil erfolgreich erstellt haben, können Sie mit dem Hinzufügen von Attributen beginnen.

package com.example.omniac;

import com.example.omniac.api.ProfileApi;
import com.example.omniac.model.Profile;
import com.example.omniac.model.ProfileCreateRequest;
import com.example.omniac.model.AttributeCreateRequest;
import com.example.omniac.model.AttributeType;
import java.util.Arrays;
import java.util.List;

public class ProfileExample {
    public static void main(String[] args) {
        // Initialize the client with your API key
        OmniacClient.initializeClient("YOUR_API_KEY_GOES_HERE");
        
        ProfileApi profileApi = new ProfileApi(OmniacClient.getApiClient());
        
        // Create a new profile
        ProfileCreateRequest newProfile = new ProfileCreateRequest()
            .name("test")
            .userLanguage("de");
        
        try {
            Profile profile = profileApi.createProfile(newProfile);
            System.out.println("Created profile with ID: " + profile.getId());
            
            // Add attributes to the profile
            AttributeCreateRequest emailAttribute = new AttributeCreateRequest()
                .type("email")
                .value("test@example.com");
            
            List<AttributeCreateRequest> attributes = Arrays.asList(emailAttribute);
            
            Object apiResponse = profileApi.replaceAttributes(profile.getId(), attributes);
            System.out.println("Attributes added: " + apiResponse);
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Mehrere Profile als Batch anlegen

Neben der Möglichkeit individuelle Profile anzulegen, bietet omniac Business auch an bis zu 500 Profile gleichzeitig mit Attributen anzulegen.

package com.example.omniac;

import java.util.ArrayList;
import java.util.List;

import com.example.omniac.api.ProfileApi;
import com.example.omniac.model.AttributeCreateRequest;
import com.example.omniac.model.CreateProfiles201Response;
import com.example.omniac.model.ProfileCreateBatchRequest;

 public static void main(String[] args) {
        // Replace with a real API key or load from environment
        OmniacClient.initializeClient("YOUR_API_KEY_GOES_HERE");

        ProfileApi profileApi = new ProfileApi(OmniacClient.getApiClient());

        List<ProfileCreateBatchRequest> batch = new ArrayList<>();

        ProfileCreateBatchRequest req = new ProfileCreateBatchRequest()
                .name("Test1")
                .userLanguage("de");

        // add attribute
        req.addAttributesItem(new AttributeCreateRequest()
                .type("email")
                .value("test@example.com")
        );

        batch.add(req);

        try {
            CreateProfiles201Response resp = profileApi.createProfiles(batch);
            System.out.println("CreateProfiles response: " + resp);
        } catch (com.example.omniac.client.ApiException e) {
            System.err.println("Error calling createProfiles: " + e.getMessage());
            e.printStackTrace();
        }
    }

Alerts abrufen

Nach einigen Minuten gehen Alerts ein, falls Lecks gefunden wurden. Sie können diese mit der Funktion „getProfile“ und Ihrer ProfileID abrufen. Mit den beiden Parametern nach der ProfileID können Sie neben den Alerts auch die Benutzerattribute (gehasht und verschlüsselt) abrufen.

package com.example.omniac;

import com.example.omniac.api.ProfileApi;
import com.example.omniac.model.Profile;

public class AlertsExample {
    public static void main(String[] args) {
        // Initialize the client with your API key
        OmniacClient.initializeClient("YOUR_API_KEY_GOES_HERE");
        
        ProfileApi profileApi = new ProfileApi(OmniacClient.getApiClient());
        
        try {
            // Replace "profileID" with your actual profile ID
            Profile profile = profileApi.getProfile("profileID", true, true);
            System.out.println("Profile with alerts: " + profile);
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Push-Benachrichtigungs-Endpunkt bereitstellen

Um Sie noch schneller zu benachrichtigen, bieten wir eine Push-API für neue Benachrichtigungen an. Sobald etwas gefunden wird, veröffentlichen wir die Benachrichtigung in Ihrem System. Dies geschieht über einen HTTP-Aufruf. Die Zustellung wird auf unserer Seite als abgeschlossen markiert, sobald Ihre API einen 2xx-HTTP-Statuscode zurückgibt.

Um diese Funktion nutzen zu können, müssen Sie sich mit uns in Verbindung setzen, damit wir die Funktion für Ihren Tenant aktivieren können.