redis_enterprise/
users.rs

1//! User and role management for Redis Enterprise
2
3use crate::client::RestClient;
4use crate::error::Result;
5use serde::{Deserialize, Serialize};
6use serde_json::Value;
7
8/// User information
9#[derive(Debug, Clone, Serialize, Deserialize)]
10pub struct User {
11    pub uid: u32,
12    pub username: String,
13    pub email: Option<String>,
14    pub role: String,
15    pub status: Option<String>,
16    pub password_issue_date: Option<String>,
17    pub email_alerts: Option<bool>,
18    pub bdbs: Option<Vec<u32>>,
19
20    #[serde(flatten)]
21    pub extra: Value,
22}
23
24/// Create user request
25#[derive(Debug, Serialize)]
26pub struct CreateUserRequest {
27    pub username: String,
28    pub password: String,
29    pub role: String,
30    #[serde(skip_serializing_if = "Option::is_none")]
31    pub email: Option<String>,
32    #[serde(skip_serializing_if = "Option::is_none")]
33    pub email_alerts: Option<bool>,
34}
35
36/// Update user request
37#[derive(Debug, Serialize)]
38pub struct UpdateUserRequest {
39    #[serde(skip_serializing_if = "Option::is_none")]
40    pub password: Option<String>,
41    #[serde(skip_serializing_if = "Option::is_none")]
42    pub role: Option<String>,
43    #[serde(skip_serializing_if = "Option::is_none")]
44    pub email: Option<String>,
45    #[serde(skip_serializing_if = "Option::is_none")]
46    pub email_alerts: Option<bool>,
47}
48
49/// Role information
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct Role {
52    pub uid: u32,
53    pub name: String,
54    pub management: Option<String>,
55    pub data_access: Option<String>,
56
57    #[serde(flatten)]
58    pub extra: Value,
59}
60
61/// User handler for managing users
62pub struct UserHandler {
63    client: RestClient,
64}
65
66impl UserHandler {
67    pub fn new(client: RestClient) -> Self {
68        UserHandler { client }
69    }
70
71    /// List all users
72    pub async fn list(&self) -> Result<Vec<User>> {
73        self.client.get("/v1/users").await
74    }
75
76    /// Get specific user
77    pub async fn get(&self, uid: u32) -> Result<User> {
78        self.client.get(&format!("/v1/users/{}", uid)).await
79    }
80
81    /// Create new user
82    pub async fn create(&self, request: CreateUserRequest) -> Result<User> {
83        self.client.post("/v1/users", &request).await
84    }
85
86    /// Update user
87    pub async fn update(&self, uid: u32, request: UpdateUserRequest) -> Result<User> {
88        self.client
89            .put(&format!("/v1/users/{}", uid), &request)
90            .await
91    }
92
93    /// Delete user
94    pub async fn delete(&self, uid: u32) -> Result<()> {
95        self.client.delete(&format!("/v1/users/{}", uid)).await
96    }
97}
98
99/// Role handler for managing roles
100pub struct RoleHandler {
101    client: RestClient,
102}
103
104impl RoleHandler {
105    pub fn new(client: RestClient) -> Self {
106        RoleHandler { client }
107    }
108
109    /// List all roles
110    pub async fn list(&self) -> Result<Vec<Role>> {
111        self.client.get("/v1/roles").await
112    }
113
114    /// Get specific role
115    pub async fn get(&self, uid: u32) -> Result<Role> {
116        self.client.get(&format!("/v1/roles/{}", uid)).await
117    }
118}