Rust API client for onesignal-rust-api

A powerful way to send personalized messages at scale and build effective customer engagement strategies. Learn more at onesignal.com

For more information, please visit https://onesignal.com

Overview

This API client was generated by the OpenAPI Generator project. By using the openapi-spec from a remote server, you can easily generate an API client.

• API version: 1.2.1
• Package version: 2.0.0
• Build package: org.openapitools.codegen.languages.RustClientCodegen
• GitHub repository: https://github.com/onesignal/onesignal-rust-api

Installation

Crates.io

You can install this library as a crate dependency https://crates.io/crates/onesignal-rust-api.

Manual installation

Put the package under your project folder in a directory named onesignal and add the following to Cargo.toml under [dependencies]:

onesignal = { path = "./onesignal" }

Examples

Use the following dependency:

```rust use onesignal::*; use onesignal::apis::configuration::Configuration; use onesignal::models::filter_expressions::RelationType; use onesignal::models::{App, FilterExpressions, Notification, Player, Segment, StringMap, UpdatePlayerTagsRequestBody};

```

Define the constants. You can find all the values on the dashboard page of your app.

```rust const APPID: &str = ""; const APPKEYTOKEN: &str = ""; const USERKEY_TOKEN: &str = "";

```

Creating a configuration object:

rust fn create_configuration() -> Box<Configuration> { let mut configuration = apis::configuration::Configuration::new(); configuration.app_key_token = Some(String::from(APP_KEY_TOKEN)); configuration.user_key_token = Some(String::from(USER_KEY_TOKEN)); Box::new(configuration) }

Creating a notification object:

```rust fn createnotification() -> Box { let mut notification = Notification::new(String::from(APPID)); let mut string_map = StringMap::new();

string_map.en = Some(String::from("Rust test notification"));
notification.contents = Some(Box::new(string_map));
notification.is_chrome_web = Some(true);
notification.is_any_web = Some(true);
notification.included_segments = Some(vec![String::from("Subscribed Users")]);

Box::new(notification)

} ```

Sending a notification:

```rust async fn sendnotification() { // Prepare configuration and the notification objects let configuration = createconfiguration(); let notification = create_notification();

// Send notification to the server
let create_notification_response = apis::default_api::create_notification(&configuration, *notification).await;

// Check the result
if let Ok(ref created_notification) = create_notification_response {
    println!("Created notification id: {}", created_notification.id);
}

if let Err(ref created_notification_error) = create_notification_response {
    println!("Created notification error: {}", created_notification_error.to_string());
}

} ```

Sending a notification using filters:

Send this notification only to the users that have not spent any USD on IAP. ```rust async fn sendnotification() { // Prepare configuration and the notification objects let configuration = createconfiguration(); let mut notification = create_notification();

notification.filters = Some(vec![
    Filter {
        field: "amount_spent".to_owned(),
        relation: onesignal_rust_api::models::filter::RelationType::Equal,
        value: Some("0".to_owned()),
        key: None
    },
]);

// Send notification to the server
let create_notification_response = apis::default_api::create_notification(&configuration, *notification).await;

// Check the result
if let Ok(ref created_notification) = create_notification_response {
    println!("Created notification id: {}", created_notification.id);
}

if let Err(ref created_notification_error) = create_notification_response {
    println!("Created notification error: {}", created_notification_error.to_string());
}

} ```

Canceling a scheduled notification

```rust async fn cancelschedulednotification() { let configuration = createconfiguration(); let mut notification = createnotification(); let sendafter = Utc::now().checkedaddsigned(Duration::seconds(30)); notification.sendafter = Some(String::from(sendafter.unwrap().torfc2822()));

let create_notification_response =
    apis::default_api::create_notification(&configuration, *notification.clone()).await;

let cancel_notification_response =
    apis::default_api::cancel_notification(
        &configuration, APP_ID, &create_notification_response.unwrap().id).await;

assert_ok!(&cancel_notification_response);
assert!(cancel_notification_response.unwrap().success.unwrap());

} ```

Getting a notification

```rust async fn getnotification() { let configuration = createconfiguration(); let notification = create_notification();

let create_notification_response =
    apis::default_api::create_notification(&configuration, *notification.clone()).await;

let get_notification_response =
    apis::default_api::get_notification(
        &configuration, APP_ID, &create_notification_response.unwrap().id).await;

assert_ok!(&get_notification_response);
assert!(get_notification_response.unwrap().id.unwrap().len() > 0);

} ```

Getting a list of notifications

```rust async fn getmultiplenotifications() { let configuration = create_configuration();

// Limit: 100
// Offset: 0
// Kind: 1
let get_notifications_response =
    apis::default_api::get_notifications(
        &configuration, APP_ID, Some(100), Some(0), Some(1)).await;

assert_ok!(&get_notifications_response);
assert!(get_notifications_response.unwrap().notifications.unwrap().len() > 0);

} ```

Creating a brand new player model

rust fn create_player() -> Box<Player> { let mut player = Box::new(Player::new("Rust Test Player".to_string(), 1)); player.app_id = Some(APP_ID.to_string()); player }

Creating and deleting a segment

```rust async fn createandgetplayer() { let configuration = createconfiguration(); let player = create_player();

let create_player_response =
    apis::default_api::create_player(&configuration, *player).await;

let get_player_response =
    apis::default_api::get_player(
        &configuration, APP_ID, &create_player_response.unwrap().id.unwrap(), None).await;

assert_ok!(&get_player_response);
assert!(get_player_response.unwrap().id.len() > 0);

} ```

Creating and updating a player

```rust async fn updateplayer() { let configuration = createconfiguration(); let player = createplayer(); let mut updatedplayer = createplayer(); updatedplayer.externaluserid = Some(String::from("test_user"));

let create_player_response =
    apis::default_api::create_player(&configuration, *player).await;

let update_player_response =
    apis::default_api::update_player(
        &configuration, &create_player_response.unwrap().id.unwrap(), *updated_player).await;

assert_ok!(&update_player_response);
assert!(update_player_response.unwrap().success.unwrap());

} ```

Updating player tags

```rust async fn updateplayertags() { let configuration = create_configuration();

let mut updated_player_tags_request_body= UpdatePlayerTagsRequestBody::new();
let tag_value = json!({"test_tag": 1});

updated_player_tags_request_body.tags = Some(tag_value);

let update_player_tags_response =
    apis::default_api::update_player_tags(
        &configuration,
        APP_ID,
        "test_user",
        Some(updated_player_tags_request_body)).await;

assert_ok!(&update_player_tags_response);
assert!(update_player_tags_response.unwrap().success.unwrap());

} ```

Getting a list of players

```rust async fn getmultipleplayers() { let configuration = create_configuration();

// Limit: 10
// Offset: 0
let get_players_response =
    apis::default_api::get_players(&configuration, APP_ID, Some(10), None).await;

assert_ok!(&get_players_response);
assert!(get_players_response.unwrap().players.unwrap().len() > 0);

} ```

Creating a segment model

```rust fn createsegment(name: String) -> Box { let mut filterexpressions = FilterExpressions::new( "sessioncount".tostring(), RelationType::GreaterThan); filterexpressions.value = Some("1".tostring()); let segment = Segment::new(name, vec![filterexpressions]);

Box::new(segment)

} ```

Creating and deleting a segment

```rust async fn createanddeletesegment() { let configuration = createconfiguration(); let segment = createsegment("testsegment");

let create_segment_response =
    apis::default_api::create_segments(&configuration, APP_ID, Some(*segment)).await;

let delete_segment_response =
    apis::default_api::delete_segments(
        &configuration, APP_ID, &create_segment_response.unwrap().id.unwrap()).await;

assert_ok!(&delete_segment_response);
assert!(delete_segment_response.unwrap().success.unwrap());

} ```

Getting an app

```rust async fn getapp() { let configuration = createconfiguration();

let get_app_response =
    apis::default_api::get_app(&configuration, APP_ID).await;

assert_ok!(&get_app_response);
assert!(get_app_response.unwrap().id.len() > 0);

} ```

Updating an app

```rust async fn updateapp() { let configuration = createconfiguration(); let mut app = App::new(APPID.tostring()); app.sitename = Some("rusttestchangedname".to_string());

let update_app_response =
    apis::default_api::update_app(&configuration, APP_ID, app).await;

assert_ok!(&update_app_response);
assert!(update_app_response.unwrap().id.len() > 0);

} ```

Getting a list of apps

```rust async fn getmultipleapps() { let configuration = create_configuration();

let get_apps_response =
    apis::default_api::get_apps(&configuration).await;

assert_ok!(&get_apps_response);
assert!(get_apps_response.unwrap().len() > 0);

} ```

Getting outcomes

```rust async fn getoutcomes() { let configuration = createconfiguration(); let outcomenames = "ossessionduration.count,osclick.count"; let outcometimerange = "1d"; let outcomeplatforms = "5"; let outcomeattribution = "direct";

let get_outcomes_response =
    apis::default_api::get_outcomes(
        &configuration,
        APP_ID,
        outcome_names,
        None,
        Some(outcome_time_range),
        Some(outcome_platforms),
        Some(outcome_attribution)).await;

assert_ok!(&get_outcomes_response);
assert!(get_outcomes_response.unwrap().outcomes.unwrap().len() > 0);

} ```

Begin a Live Activity event

```rust async fn beginliveactivity() { // Create a player first let configuration = createconfiguration(); let mut player = Box::new(Player::new("Rust Test Player".tostring(), 0)); player.appid = Some(APPID.tostring()); let createplayerresponse = apis::defaultapi::createplayer(&configuration, *player).await; let beginliveactivityrequest = BeginLiveActivityRequest { pushtoken: "", subscriptionid: createplayerresponse.unwrap().id.unwrap() }; let activity_id = "";

// Start live activity
let begin_alive_activity_response =
    apis::default_api::begin_live_activity(&configuration, APP_ID, activity_id.as_str(), begin_live_activity_request).await;

// Check the request completed successfully
assert_ok!(&begin_alive_activity_response);

} ```

Update a Live Activity event

```rust async fn endliveactivity() { let activityid = ""; let subscriptionid = ""; let updateliveactivityrequest = UpdateLiveActivityRequest { name: NameType::Contents, event: EventType::Update, eventupdates: json!({"data": "test"}), dismiss_at: None, };

// Stop Live Activity
let update_alive_activity_response =
    apis::default_api::update_live_activity(&configuration, APP_ID, activity_id.as_str(), update_live_activity_request).await;

// Check the request completed successfully
assert_ok!(&update_alive_activity_response);

} ```

End a Live Activity event

```rust async fn endliveactivity() { let activityid = ""; let subscriptionid = "";

// Stop Live Activity
let end_alive_activity_response =
    apis::default_api::end_live_activity(&configuration, APP_ID, activity_id.as_str(), subscription_id.as_str()).await;

// Check the request completed successfully
assert_ok!(&end_alive_activity_response);

} ```

Users, Subscriptions and Aliases

Subscription types

• iOSPush
• AndroidPush
• FireOSPush
• ChromeExtensionPush
• ChromePush
• WindowsPush
• SafariLegacyPush
• FirefoxPush
• macOSPush
• HuaweiPush
• SafariPush
• Email
• SMS

Creating a OneSignal user

```rust // Preparing a model let mut user = User::new(); user.identity = Some(HashMap::from([ ("".asstring(), Value::from("".asstring())), ]));

user.subscriptions = Some(vec![ SubscriptionObject { type: Some(TypeType::IOSPush), token: Some("".asstring()), id: None, enabled: None, notificationtypes: None, sessiontime: None, sessioncount: None, sdk: None, devicemodel: None, deviceos: None, rooted: None, testtype: None, appversion: None, nettype: None, carrier: None, webauth: None, webp256: None } ]);

// Send the request to the server let createuserresponse = apis::defaultapi::createuser(&configuration, APP_ID, *user).await; ```

Fetching a user by an alias

rust let fetch_user_response = apis::default_api::fetch_user(&configuration, APP_ID, "<alias_label>", "<alias_id>").await;

Fetching a user by onesignal_id, which is a special case of an alias

rust let fetch_user_response = apis::default_api::fetch_user(&configuration, APP_ID, "onesignal_id", "<alias_id>").await;

Updating a user

```rust let updateuserrequest = UpdateUserRequest { properties: Some(Box::new(PropertiesObject { tags: None, language: Some("fr".toowned()), timezoneid: None, lat: None, long: None, country: None, firstactive: None, lastactive: None, amountspent: None, purchases: None, ip: None })), refreshdevice_metadata: None, deltas: None };

let updateuserresponse = apis::defaultapi::updateuser(&configuration, APPID, "", "", updateuser_request, None)); ```

Deleting a user

rust let delete_user_response = apis::default_api::delete_user(&configuration, APP_ID, "onesignal_id", // A special case of an alias label "<alias_id>").await;

Creating new subscription

```rust let createsubscriptionrequest = CreateSubscriptionRequestBody { subscription: Some(Box::new(SubscriptionObject { id: None, type: Some(TypeType::AndroidPush), token: Some("".asstring()), enabled: None, notificationtypes: None, sessiontime: None, sessioncount: None, sdk: None, devicemodel: None, deviceos: None, rooted: None, testtype: None, appversion: None, nettype: None, carrier: None, webauth: None, webp256: None })), retainpreviousowner: None };

let createsubscriptionresponse = apis::defaultapi::createsubscription(&configuration, APPID, "", "", createsubscription_request).await; ```

Updating subscription token

```rust let updatesubscriptionrequest = UpdateSubscriptionRequestBody { subscription: Some(Box::new(SubscriptionObject { id: None, type: Some(TypeType::AndroidPush), token: Some("".asstring()), enabled: None, notificationtypes: None, sessiontime: None, sessioncount: None, sdk: None, devicemodel: None, deviceos: None, rooted: None, testtype: None, appversion: None, nettype: None, carrier: None, webauth: None, webp256: None })), retainpreviousowner: None };

let updatesubscriptionresponse = apis::defaultapi::updatesubscription(&configuration, APPID, "", updatesubscription_request).await; ```

Deleting a subscription

rust let delete_subscription_response = apis::default_api::delete_subscription(&configuration, APP_ID, "<subscription_id>").await;

Fetching user aliases

rust let fetch_aliases_response = apis::default_api::fetch_aliases(&configuration, APP_ID, "<subscription_id>").await;

Fetching user identity

rust let fetch_user_identity_response = apis::default_api::fetch_user_identity(&configuration, APP_ID, "<alias_label>", "<alias_id>").await;

Identifying user by subscription_id

rust let user_identity_request_body = UserIdentityRequestBody { identity: Some(HashMap::from([ ("<new_alias_label>".as_string(), Value::from("<new_alias_id>".as_string())), ])) }; let identify_user_response = apis::default_api::identify_user_by_subscription_id(&configuration, APP_ID, "<subscription_id>", user_identity_request_body).await;

Identifying user by an alias

rust let user_identity_request_body = UserIdentityRequestBody { identity: Some(HashMap::from([ ("<new_alias_label>".as_string(), Value::from("<new_alias_id>".as_string())), ])) }; let identify_user_response = apis::default_api::identify_user_by_alias(&configuration, APP_ID, "<alias_label>", "<alias_id>", user_identity_request_body).await;

Deleting an alias

rust let delete_alias_response = apis::default_api::delete_alias(&configuration, APP_ID, "<alias_label>", "<alias_id>", "<alias_label_to_delete>").await;

Fetching eligible IAMs

rust let fetch_iams_response = apis::default_api::get_eligible_iams(&configuration, APP_ID, "<subscription_id>");

Documentation for API Endpoints

All URIs are relative to https://onesignal.com/api/v1

Class | Method | HTTP request | Description ------------ | ------------- | ------------- | ------------- DefaultApi | beginliveactivity | POST /apps/{appid}/liveactivities/{activityid}/token | Start Live Activity *DefaultApi* | cancelnotification | DELETE /notifications/{notificationid} | Stop a scheduled or currently outgoing notification *DefaultApi* | createapp | POST /apps | Create an app DefaultApi | createnotification | POST /notifications | Create notification *DefaultApi* | createplayer | POST /players | Add a device DefaultApi | createsegments | POST /apps/{appid}/segments | Create Segments DefaultApi | createsubscription | POST /apps/{appid}/users/by/{aliaslabel}/{aliasid}/subscriptions | DefaultApi | createuser | POST /apps/{appid}/users | DefaultApi | deletealias | DELETE /apps/{appid}/users/by/{aliaslabel}/{aliasid}/identity/{aliaslabeltodelete} | *DefaultApi* | deleteplayer | DELETE /players/{playerid} | Delete a user record *DefaultApi* | deletesegments | DELETE /apps/{appid}/segments/{segmentid} | Delete Segments DefaultApi | deletesubscription | DELETE /apps/{appid}/subscriptions/{subscriptionid} | *DefaultApi* | deleteuser | DELETE /apps/{appid}/users/by/{aliaslabel}/{aliasid} | *DefaultApi* | endliveactivity | DELETE /apps/{appid}/liveactivities/{activityid}/token/{subscriptionid} | Stop Live Activity *DefaultApi* | exportplayers | POST /players/csvexport?appid={appid} | CSV export *DefaultApi* | fetchaliases | GET /apps/{appid}/subscriptions/{subscriptionid}/user/identity | DefaultApi | fetchuser | GET /apps/{appid}/users/by/{aliaslabel}/{aliasid} | DefaultApi | fetchuseridentity | GET /apps/{appid}/users/by/{aliaslabel}/{aliasid}/identity | *DefaultApi* | getapp | GET /apps/{appid} | View an app *DefaultApi* | getapps | GET /apps | View apps DefaultApi | geteligibleiams | GET /apps/{appid}/subscriptions/{subscriptionid}/iams | DefaultApi | getnotification | GET /notifications/{notificationid} | View notification DefaultApi | getnotificationhistory | POST /notifications/{notificationid}/history | Notification History *DefaultApi* | getnotifications | GET /notifications | View notifications DefaultApi | getoutcomes | GET /apps/{appid}/outcomes | View Outcomes DefaultApi | getplayer | GET /players/{playerid} | View device DefaultApi | getplayers | GET /players | View devices *DefaultApi* | identifyuserbyalias | PATCH /apps/{appid}/users/by/{aliaslabel}/{aliasid}/identity | *DefaultApi* | identifyuserbysubscriptionid | PATCH /apps/{appid}/subscriptions/{subscriptionid}/user/identity | *DefaultApi* | transfersubscription | PATCH /apps/{appid}/subscriptions/{subscriptionid}/owner | DefaultApi | updateapp | PUT /apps/{appid} | Update an app DefaultApi | updateliveactivity | POST /apps/{appid}/liveactivities/{activityid}/notifications | Update a Live Activity via Push *DefaultApi* | updateplayer | PUT /players/{playerid} | Edit device *DefaultApi* | updateplayertags | PUT /apps/{appid}/users/{externaluserid} | Edit tags with external user id DefaultApi | updatesubscription | PATCH /apps/{appid}/subscriptions/{subscriptionid} | *DefaultApi* | updateuser | PATCH /apps/{appid}/users/by/{aliaslabel}/{alias_id} |

Documentation For Models

• App
• BadRequestError
• BasicNotification
• BasicNotificationAllOf
• BasicNotificationAllOfAndroidBackgroundLayout
• BeginLiveActivityRequest
• Button
• CancelNotificationSuccessResponse
• CreateNotificationSuccessResponse
• CreatePlayerSuccessResponse
• CreateSegmentConflictResponse
• CreateSegmentSuccessResponse
• CreateSubscriptionRequestBody
• CreateUserConflictResponse
• CreateUserConflictResponseErrorsInner
• CreateUserConflictResponseErrorsItemsMeta
• DeletePlayerNotFoundResponse
• DeletePlayerSuccessResponse
• DeleteSegmentNotFoundResponse
• DeleteSegmentSuccessResponse
• DeliveryData
• ExportPlayersRequestBody
• ExportPlayersSuccessResponse
• Filter
• FilterExpressions
• GetNotificationRequestBody
• IdentifyUserConflictResponse
• IdentifyUserConflictResponseErrorsInner
• InlineResponse200
• InlineResponse2003
• InlineResponse201
• InlineResponse202
• InvalidIdentifierError
• Notification
• Notification200Errors
• NotificationAllOf
• NotificationHistorySuccessResponse
• NotificationSlice
• NotificationTarget
• NotificationWithMeta
• NotificationWithMetaAllOf
• Operator
• OutcomeData
• OutcomesData
• PlatformDeliveryData
• PlatformDeliveryDataEmailAllOf
• PlatformDeliveryDataSmsAllOf
• Player
• PlayerNotificationTarget
• PlayerNotificationTargetIncludeAliases
• PlayerSlice
• PropertiesDeltas
• PropertiesObject
• Purchase
• Segment
• SegmentNotificationTarget
• StringMap
• SubscriptionObject
• TransferSubscriptionRequestBody
• UpdateLiveActivityRequest
• UpdateLiveActivitySuccessResponse
• UpdatePlayerSuccessResponse
• UpdatePlayerTagsRequestBody
• UpdatePlayerTagsSuccessResponse
• UpdateSubscriptionRequestBody
• UpdateUserRequest
• User
• UserIdentityRequestBody
• UserIdentityResponse
• UserSubscriptionOptions

To get access to the crate's generated documentation, use:

cargo doc --open

Author

devrel@onesignal.com