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

Zur Standardansicht zurückkehren.

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.

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.

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 - 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.