Beispiel Golang

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.