livepeer_rs/user/
mod.rs

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone)]
pub struct User {
    pub client: crate::LivepeerClient,
    pub user_id: String,
    pub info: UserInfo,
}

#[derive(Debug, Clone)]
pub struct UserApi {
    pub client: crate::LivepeerClient,
    pub urls: crate::api::urls::LivepeerUrls,
}

pub trait UserTrait {
    /// Get user information by user ID
    ///
    /// # Parameters
    /// * `user_id` - The ID of the user
    ///
    /// # Returns
    /// * `Result<serde_json::Value, String>` - A JSON value containing the user information or an error message
    fn get_user_info_by_id(&self, user_id: String) -> Result<serde_json::Value, String>;
}

impl UserTrait for UserApi {
    /// Get user information by user ID
    ///
    /// # Parameters
    /// * `user_id` - The ID of the user
    ///
    /// # Returns
    /// * `Result<serde_json::Value, String>` - A JSON value containing the user information or an error message
    fn get_user_info_by_id(&self, user_id: String) -> Result<serde_json::Value, String> {
        self.clone()._get_user_info_by_id(user_id)
    }
}

impl UserApi {
    /// Create a new UserApi instance
    ///
    /// # Parameters
    /// * `client` - A reference to the LivepeerClient
    ///
    /// # Returns
    /// * `Self` - A new instance of UserApi
    pub fn new(client: &crate::LivepeerClient) -> Self {
        UserApi {
            client: client.clone(),
            urls: crate::api::urls::LivepeerUrls::new(),
        }
    }

    /// Internal method to get user information by user ID
    ///
    /// # Parameters
    /// * `user_id` - The ID of the user
    ///
    /// # Returns
    /// * `Result<serde_json::Value, String>` - A JSON value containing the user information or an error message
    pub fn _get_user_info_by_id(&self, user_id: String) -> Result<serde_json::Value, String> {
        match crate::utils::SurfRequest::get(
            format!(
                "{}{}",
                self.client.config.host,
                format!("/api/user/{}", user_id)
            ),
            self.client.clone(),
        ) {
            Ok(response) => Ok(response),
            Err(_) => Err("Error getting user info".to_string()),
        }
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserInfo {
    pub id: String,
    pub kind: String,
    pub admin: bool,
    pub email: String,
    pub last_name: Option<String>,
    pub last_seen: i64,
    pub created_at: i64,
    pub first_name: String,
    pub email_valid: bool,
    pub last_streamed_at: Option<i64>,
    pub stripe_product_id: String,
    pub stripe_customer_id: String,
    pub stripe_customer_subscription_id: String,
}

impl User {
    /// Create a new User instance
    ///
    /// # Parameters
    /// * `client` - A reference to the LivepeerClient
    ///
    /// # Returns
    /// * `Result<Self, String>` - A new instance of User or an error message
    pub fn new(client: &crate::LivepeerClient) -> Result<Self, String> {
        match get_user_info(&client) {
            Ok(user_info) => {
                let user_id = user_info.clone().id;
                Ok(User {
                    client: client.clone(),
                    user_id,
                    info: user_info,
                })
            }
            Err(err) => Err(err),
        }
    }
}

/// Get the user information from the API
///
/// # Parameters
/// * `client` - A reference to the LivepeerClient
///
/// # Returns
/// * `Result<UserInfo, String>` - A UserInfo struct containing the user information or an error message
pub fn get_user_info(client: &crate::LivepeerClient) -> Result<UserInfo, String> {
    match crate::utils::SurfRequest::get(
        format!("{}{}", client.config.host, "/api/user/me"),
        client.clone(),
    ) {
        Ok(response) => Ok(serde_json::from_value(response).unwrap()),
        Err(_) => Err("Error getting user id".to_string()),
    }
}

/// Get user information by user ID
///
/// # Parameters
/// * `client` - A reference to the LivepeerClient
/// * `user_id` - The ID of the user
///
/// # Returns
/// * `Result<UserInfo, String>` - A UserInfo struct containing the user information or an error message
pub fn get_user_info_by_id(
    client: &crate::LivepeerClient,
    user_id: String,
) -> Result<UserInfo, String> {
    match crate::utils::SurfRequest::get(
        format!("{}{}", client.config.host, format!("/api/user/{}", user_id)),
        client.clone(),
    ) {
        Ok(response) => Ok(serde_json::from_value(response).unwrap()),
        Err(_) => Err("Error getting user id".to_string()),
    }
}