Satori Unreal Client Guide

This client library guide will show you how to use the core Satori features in Unreal.

Prerequisites #

Before proceeding ensure that you have:

Access to a Satori server instance
Installed the Satori Unreal SDK

The Satori client is packaged as part of the Nakama Unreal SDK, but using Nakama is not required.

Installation #

The client is available from the:

Heroic Labs GitHub releases page

To use Satori in your Unreal project, you’ll need to copy the Satori Client files you downloaded into the appropriate place:

Open your Unreal project folder (for example, C:\\MyUnrealProject\\) in Explorer or Finder.
If one does not already exist, create a Plugins folder here.
Copy the Satori folder from the root of the downloaded release zip and put it in the Plugins folder.

Optionally: you can put the plugin inside your Unreal Engine plugin folder (for example, C:\Program Files\Epic Games\UE_5.3\Engine\Plugins\) to use the plugin across multiple projects.

Remember to add the modules to the dependencies under your project’s Build.cs file. For example:

1
PrivateDependencyModuleNames.AddRange(new string[] { "Satori" });

At this point, you are done. Restart Unreal. After it compiles everything, open Edit->Plugins, then search for “Satori”. If all went well, you should see the Satori plugin, make sure to enable it (this may prompt an editor restart).

Updates #

New versions of the Satori Unreal Client and the corresponding improvements are documented in the Release Notes.

Logging #

Logging to the console in this guide uses the Unreal specific UE_LOG macro. In the Unreal SDK use:

1
UE_LOG(LogTemp, Log, TEXT("Hello, %s!"), TEXT("Satori"));

Getting started #

Learn how to get started using the Satori Client to manage your live game.

Satori client #

The Satori Client connects to a Satori Server and is the entry point to access Satori features. It is recommended to have one client per server per game.

To create a client pass in your server connection details:

1
2
3
4
5
6
const FString ServerKey = TEXT("apiKey");
const FString Host = TEXT("127.0.0.1");
constexpr int32 Port = 7450;
constexpr bool bUseSSL = false;

ClientConfig = FSatoriClientConfig{ServerKey, Host, Port, bUseSSL};

API Keys

Create and rotate API keys in the Satori Settings page.

Configuring request retries #

To configure request retry logic:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
/** Maximum number of retry attempts (0 = no retries). */
constexpr int32 MaxRetries = 4;
/** Base delay in milliseconds before first retry. Actual delay uses exponential backoff with full jitter. */
constexpr int32 BaseDelayMs = 500;
/** Whether to automatically refresh expired sessions before making API calls. */
constexpr bool bAutoRefreshSession = true;
/** How many seconds before expiry a session is considered "about to expire" and gets refreshed. */
constexpr int64 AutoRefreshBufferSeconds = 300;
/** HTTP request timeout in seconds. */
constexpr float Timeout = 10.0f;

FSatoriRetryConfig RetryConfig = FSatoriRetryConfig{
    MaxRetries, BaseDelayMs, bAutoRefreshSession, AutoRefreshBufferSeconds, Timeout
};

This RetryConfig struct can be optionally passed into requests to override the default values.

To be notified when a session is automatically refreshed, for example to persist the new tokens, set the OnSessionRefreshed callback on the config:

1
2
3
4
RetryConfig.OnSessionRefreshed = [](const FSatoriSession& RefreshedSession)
{
    // Store RefreshedSession.Token and RefreshedSession.RefreshToken.
};

If the callback captures a UObject pointer, also set OnSessionRefreshedOwner so the callback is skipped if the object has been garbage-collected.

Authentication #

Authenticate users using the Satori Client via their unique ID.

Satori requests are asynchronous, and their callbacks run after the function that started the request has returned. Callbacks must not capture local variables by reference. The examples in this guide assume that ClientConfig, Session and any other state a callback updates, such as UserId, are members of a long-lived object such as your actor, and that WeakThis is a TWeakObjectPtr to that object created from this before the request:

1
2
3
4
5
6
// In the class declaration, for example ASagiShiActor.h
UPROPERTY()
FSatoriClientConfig ClientConfig;

UPROPERTY()
FSatoriSession Session;

When authenticating, you can optionally pass in any desired Default and/or Custom properties to be updated. If none are provided, the properties remain as they are on the server.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
const TWeakObjectPtr<ASagiShiActor> WeakThis(this);

const FString Id = FGuid::NewGuid().ToString(EGuidFormats::DigitsWithHyphens);
constexpr bool bNoSession = false;
const TMap<FString, FString> Default = {};
const TMap<FString, FString> Custom = {};

Satori::Authenticate(ClientConfig, Id, bNoSession, Default, Custom).Next(
    [WeakThis](const FSatoriSessionResult& SessionResult)
    {
       if (SessionResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error authenticating: {%d} %s"), SessionResult.Error.Code,
                 *SessionResult.Error.Message);
          return;
       }

       if (!WeakThis.IsValid())
       {
          return;
       }

       WeakThis->Session = SessionResult.Value;

       UE_LOG(LogTemp, Log, TEXT("Session has token: %s"), *WeakThis->Session.Token);
       UE_LOG(LogTemp, Log, TEXT("Session has refresh token: %s"), *WeakThis->Session.RefreshToken);
    });

When authenticated, the server responds with a JWT (JSON Web Token) containing useful properties, such as the Auth and Refresh tokens, along with the user’s Id and Username, which gets deserialized into a Session object.

For more details on effective session management, check out this guide.

Session lifecycle #

Sessions expire after five (5) minutes by default. Expiring inactive sessions is good security practice.

Satori provides ways to restore sessions, for example, when players re-launch the game, or refresh tokens to keep the session active while the game is being played.

Use the auth and refresh tokens on the session object to restore or refresh sessions.

Store these tokens using your preferred method:

1
2
Session.Token
Session.RefreshToken

Restore a session without having to re-authenticate:

1
Session.Update(Token, RefreshToken);

Automatic session refresh #

The Unreal client library includes a feature where sessions close to expiration are automatically refreshed.

This is enabled by default but can be configured when first creating the Retry Config using the following parameters:

bAutoRefreshSession - Boolean value indicating if this feature is enabled, true by default
AutoRefreshBufferSeconds - The time prior to session expiry when auto-refresh will occur, set to 5 minutes by default

Manually refreshing a session #

Sessions can be manually refreshed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
Satori::AuthenticateRefresh(ClientConfig, Session.RefreshToken).Next(
    [WeakThis](const FSatoriSessionResult& SessionResult)
    {
       if (SessionResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error refreshing session: {%d} %s"), SessionResult.Error.Code,
                 *SessionResult.Error.Message);
          return;
       }

       if (!WeakThis.IsValid())
       {
          return;
       }

       WeakThis->Session = SessionResult.Value;

       UE_LOG(LogTemp, Log, TEXT("Session has token: %s"), *WeakThis->Session.Token);
       UE_LOG(LogTemp, Log, TEXT("Session has refresh token: %s"), *WeakThis->Session.RefreshToken);
    });

Ending sessions #

Logout and end the current session:

1
2
3
4
5
6
7
8
9
Satori::AuthenticateLogout(ClientConfig, Session.Token, Session.RefreshToken).Next(
    [](const FSatoriVoidResult& LogoutResult)
    {
       if (LogoutResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error logging out: {%d} %s"), LogoutResult.Error.Code,
                 *LogoutResult.Error.Message);
       }
    });

Identities #

Satori Identities identify individual players of your game and can be enriched with custom properties.

List an identity’s properties #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Satori::ListProperties(ClientConfig, Session).Next(
    [](const FSatoriPropertiesResult& ListPropertiesResult)
    {
       if (ListPropertiesResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error listing properties: {%d} %s"),
                 ListPropertiesResult.Error.Code,
                 *ListPropertiesResult.Error.Message);
          return;
       }

       for (TTuple Property : ListPropertiesResult.Value.Default)
       {
          UE_LOG(LogTemp, Log, TEXT("Default Property found: %s with value %s"),
                 *Property.Key, *Property.Value);
       }

       for (TTuple Property : ListPropertiesResult.Value.Custom)
       {
          UE_LOG(LogTemp, Log, TEXT("Custom Property found: %s with value %s"), *Property.Key,
                 *Property.Value);
       }

       for (TTuple Property : ListPropertiesResult.Value.Computed)
       {
          UE_LOG(LogTemp, Log, TEXT("Computed Property found: %s with value %s"),
                 *Property.Key, *Property.Value);
       }
    });

Update an identity’s properties #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
constexpr bool bRecompute = true;
const TMap<FString, FString> DefaultProperties = {
    { TEXT("defaultPropertyKey"), TEXT("defaultPropertyValue") },
    { TEXT("anotherDefaultPropertyKey"), TEXT("anotherDefaultPropertyValue") }
};
const TMap<FString, FString> CustomProperties = {
    { TEXT("customPropertyKey"), TEXT("customPropertyValue") },
    { TEXT("anotherCustomPropertyKey"), TEXT("anotherCustomPropertyValue") }
};

Satori::UpdateProperties(ClientConfig, Session, bRecompute, DefaultProperties, CustomProperties).Next(
    [](const FSatoriVoidResult& UpdatePropertiesResult)
    {
       if (UpdatePropertiesResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error updating properties: {%d} %s"),
                 UpdatePropertiesResult.Error.Code,
                 *UpdatePropertiesResult.Error.Message);
       }
    });

You can immediately reevaluate the identity’s audience memberships upon updating their properties by passing bRecompute as true:

1
2
3
constexpr bool bRecompute = true;

// Same as previous snippet...

Identifying a session with a new ID #

If you want to submit events to Satori before a user has authenticated with the game backend (e.g. Nakama) and has a User ID, you should authenticate with Satori using a temporary ID, such as the device’s unique identifier or a randomly generated one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const FString Id = FPlatformMisc::GetDeviceId();
constexpr bool bNoSession = false;
const TMap<FString, FString> Default = {};
const TMap<FString, FString> Custom = {};

Satori::Authenticate(ClientConfig, Id, bNoSession, Default, Custom).Next(
    [WeakThis](const FSatoriSessionResult& SessionResult)
    {
       if (SessionResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error authenticating: {%d} %s"),
                 SessionResult.Error.Code, *SessionResult.Error.Message);
          return;
       }

       if (!WeakThis.IsValid())
       {
          return;
       }

       WeakThis->Session = SessionResult.Value;

       UE_LOG(LogTemp, Log, TEXT("Session has token: %s"), *WeakThis->Session.Token);
       UE_LOG(LogTemp, Log, TEXT("Session has refresh token: %s"), *WeakThis->Session.RefreshToken);
    });

You can then submit events before the user has authenticated with the game backend.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
FSatoriEvent EventOne = FSatoriEvent{};
EventOne.Name = TEXT("gameLaunched");
EventOne.Timestamp = FDateTime::UtcNow();

const TArray Events = { EventOne };

Satori::Event(ClientConfig, Session, Events).Next([](const FSatoriVoidResult& EventResult)
{
    if (EventResult.bIsError)
    {
       UE_LOG(LogTemp, Error, TEXT("Error publishing event: {%d} %s"), EventResult.Error.Code,
              *EventResult.Error.Message);
    }
});

The user would then authenticate with the game backend and retrieve their User ID.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Nakama::AuthenticateEmail(NakamaClientConfig, false, TEXT(""), TEXT("example@heroiclabs.com"), TEXT("password")).
    Next([WeakThis](const FNakamaSessionResult& SessionResult)
    {
       if (SessionResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error authenticating: {%d} %s"),
                 SessionResult.Error.Code, *SessionResult.Error.Message);
          return;
       }

       if (!WeakThis.IsValid())
       {
          return;
       }

       WeakThis->UserId = SessionResult.Value.UserId;
    });

Once a user has successfully authenticated, you should then call Satori::Identify to enrich the current session and return a new session that should be used for submitting future events.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
Satori::Identify(ClientConfig, Session, UserId, Default, Custom).Next(
    [WeakThis](const FSatoriSessionResult& IdentifyResult)
    {
       if (IdentifyResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error enriching session: {%d} %s"),
                 IdentifyResult.Error.Code, *IdentifyResult.Error.Message);
          return;
       }

       if (!WeakThis.IsValid())
       {
          return;
       }

       WeakThis->Session = IdentifyResult.Value;

       UE_LOG(LogTemp, Log, TEXT("Session has token: %s"), *WeakThis->Session.Token);
       UE_LOG(LogTemp, Log, TEXT("Session has refresh token: %s"), *WeakThis->Session.RefreshToken);
    });

Note that the old session is no longer valid and cannot be used after this.

Deleting an identity #

Delete the calling identity and its associated data:

1
2
3
4
5
6
7
8
Satori::DeleteIdentity(ClientConfig, Session).Next([](const FSatoriVoidResult& DeleteResult)
{
    if (DeleteResult.bIsError)
    {
       UE_LOG(LogTemp, Error, TEXT("Error deleting identity: {%d} %s"), DeleteResult.Error.Code,
              *DeleteResult.Error.Message);
    }
});

Experiments #

Satori Experiments allow you to test different game features and configurations in a live game.

List the current experiments for this identity:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
const TArray<FString> Names = {};
const TArray<FString> Labels = {};

Satori::GetExperiments(ClientConfig, Session, Names, Labels).Next(
    [](const FSatoriExperimentListResult& ExperimentListResult)
    {
       if (ExperimentListResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error getting experiments out: {%d} %s"),
                 ExperimentListResult.Error.Code,
                 *ExperimentListResult.Error.Message);
          return;
       }

       for (FSatoriExperiment Experiment : ExperimentListResult.Value.Experiments)
       {
          UE_LOG(LogTemp, Log, TEXT("Experiment found: %s"), *Experiment.Name);
       }
    });

You can also specify an array of experiment names and/or category labels you wish to get:

1
2
3
4
const TArray<FString> Names = { TEXT("ExperimentOne"), TEXT("ExperimentTwo") };
const TArray<FString> Labels = { TEXT("LabelOne"), TEXT("LabelTwo") };

// Same as previous snippet...

Feature flags #

Satori feature flags allow you to remotely configure game parameters in a live game.

Listing active feature flags #

List all active feature flags for the identity:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
const TArray<FString> Names = {};
const TArray<FString> Labels = {};

Satori::GetFlags(ClientConfig, Session, Names, Labels).Next(
    [](const FSatoriFlagListResult& FlagListResult)
    {
       if (FlagListResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error getting flags: {%d} %s"),
                 FlagListResult.Error.Code, *FlagListResult.Error.Message);
          return;
       }

       for (FSatoriFlag Flag : FlagListResult.Value.Flags)
       {
          UE_LOG(LogTemp, Log, TEXT("Flag found: %s with value: %s"), *Flag.Name,
                 *Flag.Value);
       }
    });

You can also specify an array of feature flag names and/or by category labels you wish to get:

1
2
3
4
const TArray<FString> Names = { TEXT("FlagOne"), TEXT("FlagTwo") };
const TArray<FString> Labels = { TEXT("LabelOne"), TEXT("LabelTwo") };

// Same as previous snippet...

Listing all feature flags #

List all available feature flags and their value overrides for this identity:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const TArray<FString> Names = {};
const TArray<FString> Labels = {};

Satori::GetFlagOverrides(ClientConfig, Session, Names, Labels).Next(
    [](const FSatoriFlagOverrideListResult& FlagOverrideListResult)
    {
       if (FlagOverrideListResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error getting flags: {%d} %s"),
                 FlagOverrideListResult.Error.Code,
                 *FlagOverrideListResult.Error.Message);
          return;
       }

       for (FSatoriFlagOverride Flag : FlagOverrideListResult.Value.Flags)
       {
          UE_LOG(LogTemp, Log, TEXT("Flag found: %s"), *Flag.FlagName);

          for (FSatoriFlagOverrideValue Override : Flag.Overrides)
          {
             UE_LOG(LogTemp, Log, TEXT("Override found: %s with value %s"), *Override.Name,
                    *Override.Value);
          }
       }
    });

You can also specify an array of feature flag names and/or by category labels you wish to get:

1
2
3
4
const TArray<FString> Names = { TEXT("FlagOne"), TEXT("FlagTwo") };
const TArray<FString> Labels = { TEXT("LabelOne"), TEXT("LabelTwo") };

// Same as previous snippet...

Events #

Satori Events allow you to send data for a given identity to the server for processing.

Metadata Limits

The maximum size of the metadata field is 4096 bytes.

Sending single events #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
FSatoriEvent EventOne = FSatoriEvent{};
EventOne.Name = TEXT("gameFinished");
EventOne.Timestamp = FDateTime::UtcNow();
EventOne.Metadata = { { TEXT("meta"), TEXT("data") } };

const TArray Events = { EventOne };

Satori::Event(ClientConfig, Session, Events).Next([](const FSatoriVoidResult& EventResult)
{
    if (EventResult.bIsError)
    {
       UE_LOG(LogTemp, Error, TEXT("Error publishing event: {%d} %s"), EventResult.Error.Code,
              *EventResult.Error.Message);
    }
});

Sending multiple events #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
FSatoriEvent EventTwo = FSatoriEvent{};
EventTwo.Name = TEXT("adStarted");
EventTwo.Timestamp = FDateTime::UtcNow();
EventTwo.Metadata = { { TEXT("meta"), TEXT("data") } };

FSatoriEvent EventThree = FSatoriEvent{};
EventThree.Name = TEXT("appLaunched");
EventThree.Timestamp = FDateTime::UtcNow();
EventThree.Metadata = { { TEXT("meta"), TEXT("data") } };

const TArray Events = { EventTwo, EventThree };

// Same as previous snippet...

Sending events from your server #

To send events from your game server using the Satori HTTP key instead of a player session, use Satori::ServerEvent:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const FString HttpKey = TEXT("<HttpKey>");

Satori::ServerEvent(ClientConfig, HttpKey, Events).Next([](const FSatoriVoidResult& EventResult)
{
    if (EventResult.bIsError)
    {
       UE_LOG(LogTemp, Error, TEXT("Error publishing event: {%d} %s"), EventResult.Error.Code,
              *EventResult.Error.Message);
    }
});

Live events #

Satori Live Events allow you to deliver established features to your players on a custom schedule.

List live events #

Get active, past, and upcoming live events for the authenticated player.

You can optionally include a number of past or future runs, or filter by event name.

Names — optional list of event names to filter
Labels — optional list of category labels to filter
PastRunCount — number of past runs to return
FutureRunCount — number of upcoming runs to return

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// List live events for the current player.
// Returns ACTIVE events by default.

const TArray<FString> Names = {};
const TArray<FString> Labels = {};
constexpr int32 PastRunCount = 0;
constexpr int32 FutureRunCount = 0;
constexpr int64 StartTimeSec = 0;
constexpr int64 EndTimeSec = 0;

Satori::GetLiveEvents(ClientConfig, Session, Names, Labels, PastRunCount, FutureRunCount, StartTimeSec, EndTimeSec).
    Next([](const FSatoriLiveEventListResult& LiveEventListResult)
    {
       if (LiveEventListResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error listing live events: {%d} %s"),
                 LiveEventListResult.Error.Code,
                 *LiveEventListResult.Error.Message);
          return;
       }

       for (FSatoriLiveEvent LiveEvent : LiveEventListResult.Value.LiveEvents)
       {
          UE_LOG(LogTemp, Log, TEXT("Live Event found: %s with value %s"), *LiveEvent.Name,
                 *LiveEvent.Value);
       }

       for (FSatoriLiveEvent ExplicitJoinLiveEvent : LiveEventListResult.Value.ExplicitJoinLiveEvents)
       {
          UE_LOG(LogTemp, Log, TEXT("Explicit Join Live Event found: %s with value %s"),
                 *ExplicitJoinLiveEvent.Name, *ExplicitJoinLiveEvent.Value);
       }
    });

Include 1 past run and 2 upcoming runs

1
2
3
constexpr int32 PastRunCount = 1;
constexpr int32 FutureRunCount = 2;
// Same as previous snippet...

Filter by specific event names

1
const TArray<FString> Names = { TEXT("Season Pass") };

Each returned event includes a status field:

TERMINATED — past events
ACTIVE — ongoing events
UPCOMING — scheduled but not yet started

Join live event explicitly #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const FString LiveEventId = TEXT("live-event-id");

Satori::JoinLiveEvent(ClientConfig, Session, LiveEventId).Next([](const FSatoriVoidResult& JoinResult)
{
    if (JoinResult.bIsError)
    {
       UE_LOG(LogTemp, Error, TEXT("Error joining live event: {%d} %s"), JoinResult.Error.Code,
              *JoinResult.Error.Message);
    }
});

Messages #

Satori integrates with various messaging services to send messages to users via message schedules. You can list a user’s messages, update a message’s status, and delete a message.

List messages #

List all messages for the calling identity:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
constexpr int32 Limit = 10;
constexpr bool bForward = true;
const FString Cursor = TEXT("");
const TArray<FString> MessageIds = {};

Satori::GetMessageList(ClientConfig, Session, Limit, bForward, Cursor, MessageIds).Next(
    [](const FSatoriGetMessageListResponseResult& MessageListResult)
    {
       if (MessageListResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error listing messages: {%d} %s"),
                 MessageListResult.Error.Code,
                 *MessageListResult.Error.Message);
          return;
       }

       for (FSatoriMessage Message : MessageListResult.Value.Messages)
       {
          UE_LOG(LogTemp, Log, TEXT("Message found: %s with text: %s"), *Message.Title,
                 *Message.Text);
       }
    });

Update message status #

Update the status of a message:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
const FString MessageId = TEXT("messageId");
// Both ConsumeTime and ReadTime should be Unix Timestamps
const int64 ReadTime = FDateTime::UtcNow().ToUnixTimestamp();
const int64 ConsumeTime = FDateTime::UtcNow().ToUnixTimestamp();

Satori::UpdateMessage(ClientConfig, Session, MessageId, ReadTime, ConsumeTime).Next(
    [](const FSatoriVoidResult& UpdateResult)
    {
       if (UpdateResult.bIsError)
       {
          UE_LOG(LogTemp, Error, TEXT("Error updating message: {%d} %s"),
                 UpdateResult.Error.Code, *UpdateResult.Error.Message);
       }
    });

Delete message #

Delete a scheduled message:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const FString MessageId = TEXT("messageId");

Satori::DeleteMessage(ClientConfig, Session, MessageId).Next([](const FSatoriVoidResult& DeleteResult)
{
    if (DeleteResult.bIsError)
    {
       UE_LOG(LogTemp, Error, TEXT("Error deleting message: {%d} %s"), DeleteResult.Error.Code,
              *DeleteResult.Error.Message);
    }
});

Heroic Cloud