onesignal-rust-api 的 Rust API 客户端

一种强大的方式，用于大规模发送个性化消息并构建有效的客户参与策略。更多信息请访问 onesignal.com

更多信息，请访问 https://onesignal.com

概述

此 API 客户端由 OpenAPI Generator 项目生成。通过使用来自远程服务器的 openapi-spec，您可以轻松生成 API 客户端。

• API 版本：1.2.2
• 包版本：2.0.2
• 构建包：org.openapitools.codegen.languages.RustClientCodegen
• GitHub 仓库：https://github.com/onesignal/onesignal-rust-api

安装

Crates.io

您可以将此库作为 crate 依赖项安装 https://crates.io/crates/onesignal-rust-api。

手动安装

将包放在您的项目文件夹中名为 onesignal 的目录下，并在 Cargo.toml 中的 [dependencies] 下添加以下内容

onesignal = { path = "./onesignal" }

示例

使用以下依赖项

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

定义常量。您可以在应用程序仪表板页面上找到所有值。

const APP_ID: &str = "<YOUR_APP_ID>";
const APP_KEY_TOKEN: &str = "<YOUR_APP_KEY_TOKEN>";
const USER_KEY_TOKEN: &str = "<YOUR_USER_KEY_TOKEN>";

创建配置对象

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)
}

创建通知对象

fn create_notification() -> Box<Notification> {
    let mut notification = Notification::new(String::from(APP_ID));
    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)
}

发送通知

async fn send_notification() {
    // Prepare configuration and the notification objects
    let configuration = create_configuration();
    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());
    }
}

使用过滤器发送通知

仅向未在 IAP 上花费任何 USD 的用户发送此通知。

async fn send_notification() {
    // Prepare configuration and the notification objects
    let configuration = create_configuration();
    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());
    }
}

取消计划的通知

async fn cancel_scheduled_notification() {
    let configuration = create_configuration();
    let mut notification = create_notification();
    let send_after = Utc::now().checked_add_signed(Duration::seconds(30));
    notification.send_after = Some(String::from(send_after.unwrap().to_rfc2822()));

    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());
}

获取通知

async fn get_notification() {
    let configuration = create_configuration();
    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);
}

获取通知列表

async fn get_multiple_notifications() {
    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);
}

创建全新的玩家模型

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
}

创建和删除细分市场

async fn create_and_get_player() {
    let configuration = create_configuration();
    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);
}

创建和更新玩家

async fn update_player() {
    let configuration = create_configuration();
    let player = create_player();
    let mut updated_player = create_player();
    updated_player.external_user_id = 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());
}

更新玩家标签

async fn update_player_tags() {
    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());
}

获取玩家列表

async fn get_multiple_players() {
    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);
}

创建细分市场模型

fn create_segment(name: String) -> Box<Segment> {
    let mut filter_expressions = FilterExpressions::new(
        "session_count".to_string(),
        RelationType::Greater_Than);
    filter_expressions.value = Some("1".to_string());
    let segment = Segment::new(name, vec![filter_expressions]);

    Box::new(segment)
}

创建和删除细分市场

async fn create_and_delete_segment() {
    let configuration = create_configuration();
    let segment = create_segment("test_segment");

    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());
}

获取应用程序

async fn get_app() {
    let configuration = create_configuration();

    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);
}

更新应用程序

async fn update_app() {
    let configuration = create_configuration();
    let mut app = App::new(APP_ID.to_string());
    app.site_name = Some("rust_test_changed_name".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);
}

获取应用程序列表

async fn get_multiple_apps() {
    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);
}

获取结果

async fn get_outcomes() {
    let configuration = create_configuration();
    let outcome_names = "os__session_duration.count,os__click.count";
    let outcome_time_range = "1d";
    let outcome_platforms = "5";
    let outcome_attribution = "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);
}

开始 Live Activity 事件

async fn begin_live_activity() {
    // Create a player first
    let configuration = create_configuration();
    let mut player = Box::new(Player::new("Rust Test Player".to_string(), 0));
    player.app_id = Some(APP_ID.to_string());
    let create_player_response =
        apis::default_api::create_player(&configuration, *player).await;
    let begin_live_activity_request = BeginLiveActivityRequest {
        push_token: "<push_token_example>",
        subscription_id: create_player_response.unwrap().id.unwrap()
    };
    let activity_id = "<activity_id_example>";

    // 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);
}

更新 Live Activity 事件

async fn end_live_activity() {
    let activity_id = "<activity_id_example>";
    let subscription_id = "<player_id_example>";
    let update_live_activity_request = UpdateLiveActivityRequest {
        name: NameType::Contents,
        event: EventType::Update,
        event_updates: 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);
}

结束 Live Activity 事件

async fn end_live_activity() {
    let activity_id = "<activity_id_example>";
    let subscription_id = "<player_id_example>";

    // 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);
}

用户、订阅和别名

订阅类型

• iOSPush
• AndroidPush
• FireOSPush
• ChromeExtensionPush
• ChromePush
• WindowsPush
• SafariLegacyPush
• FirefoxPush
• macOSPush
• 华为Push
• SafariPush
• Email
• SMS

创建 OneSignal 用户

// Preparing a model
let mut user = User::new();
user.identity = Some(HashMap::from([
    ("<your_alias_label>".as_string(), Value::from("<your_alias_id>".as_string())),
]));

user.subscriptions = Some(vec![
    SubscriptionObject {
        _type: Some(TypeType::IOSPush),
        token: Some("<ios_push_token>".as_string()),
        id: None,
        enabled: None,
        notification_types: None,
        session_time: None,
        session_count: None,
        sdk: None,
        device_model: None,
        device_os: None,
        rooted: None,
        test_type: None,
        app_version: None,
        net_type: None,
        carrier: None,
        web_auth: None,
        web_p256: None
    }
]);

// Send the request to the server
let create_user_response = apis::default_api::create_user(&configuration, APP_ID, *user).await;

通过别名获取用户

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

通过 onesignal_id 获取用户，这是别名的特殊情况

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

更新用户

let update_user_request = UpdateUserRequest {
    properties: Some(Box::new(PropertiesObject {
        tags: None,
        language: Some("fr".to_owned()),
        timezone_id: None,
        lat: None,
        long: None,
        country: None,
        first_active: None,
        last_active: None,
        amount_spent: None,
        purchases: None,
        ip: None
    })),
    refresh_device_metadata: None,
    deltas: None
};

let update_user_response = apis::default_api::update_user(&configuration,
                                                          APP_ID,
                                                          "<alias_label>",
                                                          "<alias_id>",
                                                          update_user_request,
                                                          None));

删除用户

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

创建新的订阅

let create_subscription_request = CreateSubscriptionRequestBody {
    subscription: Some(Box::new(SubscriptionObject {
        id: None,
        _type: Some(TypeType::AndroidPush),
        token: Some("<android_push_token>".as_string()),
        enabled: None,
        notification_types: None,
        session_time: None,
        session_count: None,
        sdk: None,
        device_model: None,
        device_os: None,
        rooted: None,
        test_type: None,
        app_version: None,
        net_type: None,
        carrier: None,
        web_auth: None,
        web_p256: None
    })),
    retain_previous_owner: None
};

let create_subscription_response = apis::default_api::create_subscription(&configuration,
                                                                          APP_ID,
                                                                          "<alias_label>",
                                                                          "<alias_id>",
                                                                          create_subscription_request).await;

更新订阅令牌

let update_subscription_request = UpdateSubscriptionRequestBody {
    subscription: Some(Box::new(SubscriptionObject {
        id: None,
        _type: Some(TypeType::AndroidPush),
        token: Some("<new_android_push_token>".as_string()),
        enabled: None,
        notification_types: None,
        session_time: None,
        session_count: None,
        sdk: None,
        device_model: None,
        device_os: None,
        rooted: None,
        test_type: None,
        app_version: None,
        net_type: None,
        carrier: None,
        web_auth: None,
        web_p256: None
    })),
    retain_previous_owner: None
};

let update_subscription_response = apis::default_api::update_subscription(&configuration,
                                                                          APP_ID,
                                                                          "<subscription_id>",
                                                                          update_subscription_request).await;

删除订阅

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

获取用户别名

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

获取用户身份

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

通过 subscription_id 识别用户

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;

通过别名识别用户

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;

删除别名

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

获取符合条件的 IAM

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

API端点文档

所有URI相对于 https://onesignal.com/api/v1

模型文档

• App
• BasicNotification
• BasicNotificationAllOf
• BasicNotificationAllOfAndroidBackgroundLayout
• BeginLiveActivityRequest
• Button
• CancelNotificationSuccessResponse
• CreateNotificationSuccessResponse
• CreatePlayerSuccessResponse
• CreateSegmentConflictResponse
• CreateSegmentSuccessResponse
• CreateSubscriptionRequestBody
• CreateUserConflictResponse
• CreateUserConflictResponseErrorsInner
• CreateUserConflictResponseErrorsItemsMeta
• DeletePlayerNotFoundResponse
• DeletePlayerSuccessResponse
• 删除段未找到响应
• 删除段成功响应
• 投递数据
• 导出事件成功响应
• 导出玩家请求体
• 导出玩家成功响应
• 过滤器
• 过滤表达式
• 通用错误
• 通用错误错误内部
• 获取通知请求体
• 内联响应200
• 内联响应2003
• 内联响应201
• 内联响应202
• 无效标识符错误
• 通知
• 通知200错误
• 通知全部
• 通知历史成功响应
• 通知切片
• 通知目标
• 通知带元数据
• 通知带元数据全部
• 操作员
• 结果数据
• 结果数据
• 平台投递数据
• 平台投递数据电子邮件全部
• 平台投递数据短信全部
• 玩家
• 玩家通知目标
• 玩家通知目标包含别名
• 玩家切片
• 属性变化
• 属性对象
• 购买
• 速率限制器错误
• 段
• 段通知目标
• 字符串映射
• 订阅对象
• 传输订阅请求体
• 更新实时活动请求
• 更新实时活动成功响应
• 更新玩家成功响应
• 更新玩家标签请求体
• 更新玩家标签成功响应
• 更新订阅请求体
• 更新用户请求
• 用户
• 用户身份请求体
• 用户身份响应
• 用户订阅选项

要获取对生成的文档的访问权限，请使用

cargo doc --open

作者

[email protected]