open_lark/service/cloud_docs/permission/member/
create.rs

1use reqwest::Method;
2use serde::{Deserialize, Serialize};
3
4use crate::core::{
5    api_req::ApiRequest,
6    api_resp::{ApiResponseTrait, BaseResponse, ResponseFormat},
7    config::Config,
8    constants::AccessTokenType,
9    endpoints::{cloud_docs::*, EndpointBuilder},
10    http::Transport,
11    req_option::RequestOption,
12    SDKResult,
13};
14
15use super::batch_create::Permission;
16
17/// 增加协作者权限请求
18#[derive(Debug, Serialize, Default, Clone)]
19pub struct CreatePermissionMemberRequest {
20    #[serde(skip)]
21    api_request: ApiRequest,
22    /// 文档token
23    #[serde(skip)]
24    token: String,
25    /// 文档类型
26    #[serde(skip)]
27    obj_type: String,
28    /// 协作者ID类型
29    member_type: String,
30    /// 协作者ID
31    member_id: String,
32    /// 权限
33    perm: Permission,
34    /// 是否通知
35    #[serde(skip_serializing_if = "Option::is_none")]
36    need_notification: Option<bool>,
37}
38
39impl CreatePermissionMemberRequest {
40    pub fn builder() -> CreatePermissionMemberRequestBuilder {
41        CreatePermissionMemberRequestBuilder::default()
42    }
43
44    pub fn new(
45        token: impl ToString,
46        obj_type: impl ToString,
47        member_type: impl ToString,
48        member_id: impl ToString,
49        permission: Permission,
50    ) -> Self {
51        Self {
52            token: token.to_string(),
53            obj_type: obj_type.to_string(),
54            member_type: member_type.to_string(),
55            member_id: member_id.to_string(),
56            perm: permission,
57            ..Default::default()
58        }
59    }
60
61    /// 为用户添加权限
62    pub fn for_user(
63        token: impl ToString,
64        obj_type: impl ToString,
65        user_id: impl ToString,
66        permission: Permission,
67    ) -> Self {
68        Self::new(token, obj_type, "user", user_id, permission)
69    }
70
71    /// 为群组添加权限
72    pub fn for_chat(
73        token: impl ToString,
74        obj_type: impl ToString,
75        chat_id: impl ToString,
76        permission: Permission,
77    ) -> Self {
78        Self::new(token, obj_type, "chat", chat_id, permission)
79    }
80
81    /// 为部门添加权限
82    pub fn for_department(
83        token: impl ToString,
84        obj_type: impl ToString,
85        department_id: impl ToString,
86        permission: Permission,
87    ) -> Self {
88        Self::new(token, obj_type, "department", department_id, permission)
89    }
90}
91
92#[derive(Default)]
93pub struct CreatePermissionMemberRequestBuilder {
94    request: CreatePermissionMemberRequest,
95}
96
97impl CreatePermissionMemberRequestBuilder {
98    /// 文档token
99    pub fn token(mut self, token: impl ToString) -> Self {
100        self.request.token = token.to_string();
101        self
102    }
103
104    /// 文档类型
105    pub fn obj_type(mut self, obj_type: impl ToString) -> Self {
106        self.request.obj_type = obj_type.to_string();
107        self
108    }
109
110    /// 设置为文档类型
111    pub fn as_doc(mut self) -> Self {
112        self.request.obj_type = "doc".to_string();
113        self
114    }
115
116    /// 设置为电子表格类型
117    pub fn as_sheet(mut self) -> Self {
118        self.request.obj_type = "sheet".to_string();
119        self
120    }
121
122    /// 设置为多维表格类型
123    pub fn as_bitable(mut self) -> Self {
124        self.request.obj_type = "bitable".to_string();
125        self
126    }
127
128    /// 设置为知识库类型
129    pub fn as_wiki(mut self) -> Self {
130        self.request.obj_type = "wiki".to_string();
131        self
132    }
133
134    /// 协作者类型和ID
135    pub fn member(mut self, member_type: impl ToString, member_id: impl ToString) -> Self {
136        self.request.member_type = member_type.to_string();
137        self.request.member_id = member_id.to_string();
138        self
139    }
140
141    /// 用户协作者
142    pub fn user(mut self, user_id: impl ToString) -> Self {
143        self.request.member_type = "user".to_string();
144        self.request.member_id = user_id.to_string();
145        self
146    }
147
148    /// 群组协作者
149    pub fn chat(mut self, chat_id: impl ToString) -> Self {
150        self.request.member_type = "chat".to_string();
151        self.request.member_id = chat_id.to_string();
152        self
153    }
154
155    /// 部门协作者
156    pub fn department(mut self, department_id: impl ToString) -> Self {
157        self.request.member_type = "department".to_string();
158        self.request.member_id = department_id.to_string();
159        self
160    }
161
162    /// 权限
163    pub fn permission(mut self, permission: Permission) -> Self {
164        self.request.perm = permission;
165        self
166    }
167
168    /// 设置为所有者权限
169    pub fn as_owner(mut self) -> Self {
170        self.request.perm = Permission::FullAccess;
171        self
172    }
173
174    /// 设置为编辑权限
175    pub fn as_editor(mut self) -> Self {
176        self.request.perm = Permission::Edit;
177        self
178    }
179
180    /// 设置为评论权限
181    pub fn as_commenter(mut self) -> Self {
182        self.request.perm = Permission::Comment;
183        self
184    }
185
186    /// 设置为查看权限
187    pub fn as_viewer(mut self) -> Self {
188        self.request.perm = Permission::View;
189        self
190    }
191
192    /// 是否通知
193    pub fn need_notification(mut self, need: bool) -> Self {
194        self.request.need_notification = Some(need);
195        self
196    }
197
198    /// 启用通知
199    pub fn with_notification(mut self) -> Self {
200        self.request.need_notification = Some(true);
201        self
202    }
203
204    /// 禁用通知
205    pub fn without_notification(mut self) -> Self {
206        self.request.need_notification = Some(false);
207        self
208    }
209
210    pub fn build(mut self) -> CreatePermissionMemberRequest {
211        self.request.api_request.body = serde_json::to_vec(&self.request).unwrap();
212        self.request
213    }
214}
215
216crate::impl_executable_builder_owned!(
217    CreatePermissionMemberRequestBuilder,
218    crate::service::cloud_docs::permission::PermissionService,
219    CreatePermissionMemberRequest,
220    BaseResponse<CreatePermissionMemberResponse>,
221    create_member
222);
223
224/// 协作者创建结果
225#[derive(Debug, Deserialize)]
226pub struct PermissionMemberCreated {
227    /// 协作者ID类型
228    pub member_type: String,
229    /// 协作者ID
230    pub member_id: String,
231    /// 权限
232    pub perm: Permission,
233    /// 创建时间（毫秒时间戳）
234    pub create_time: Option<i64>,
235    /// 是否通知了用户
236    pub notified: Option<bool>,
237}
238
239/// 增加协作者权限响应
240#[derive(Debug, Deserialize)]
241pub struct CreatePermissionMemberResponse {
242    /// 协作者信息
243    pub member: PermissionMemberCreated,
244}
245
246impl ApiResponseTrait for CreatePermissionMemberResponse {
247    fn data_format() -> ResponseFormat {
248        ResponseFormat::Data
249    }
250}
251
252/// 增加协作者权限
253pub async fn create_permission_member(
254    request: CreatePermissionMemberRequest,
255    config: &Config,
256    option: Option<RequestOption>,
257) -> SDKResult<BaseResponse<CreatePermissionMemberResponse>> {
258    let mut api_req = request.api_request;
259    api_req.http_method = Method::POST;
260    api_req.api_path = format!(
261        "{}?type={}",
262        EndpointBuilder::replace_param(DRIVE_V1_PERMISSIONS_MEMBERS, "token", &request.token),
263        request.obj_type
264    );
265
266    // 添加通知参数
267    if let Some(need_notification) = request.need_notification {
268        api_req.api_path = format!(
269            "{}&need_notification={}",
270            api_req.api_path, need_notification
271        );
272    }
273
274    api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
275
276    let api_resp = Transport::request(api_req, config, option).await?;
277    Ok(api_resp)
278}
279
280impl PermissionMemberCreated {
281    /// 获取成员ID
282    pub fn member_id(&self) -> &str {
283        &self.member_id
284    }
285
286    /// 获取成员类型
287    pub fn member_type(&self) -> &str {
288        &self.member_type
289    }
290
291    /// 获取权限
292    pub fn permission(&self) -> &Permission {
293        &self.perm
294    }
295
296    /// 是否是用户
297    pub fn is_user(&self) -> bool {
298        self.member_type == "user"
299    }
300
301    /// 是否是群组
302    pub fn is_chat(&self) -> bool {
303        self.member_type == "chat"
304    }
305
306    /// 是否是部门
307    pub fn is_department(&self) -> bool {
308        self.member_type == "department"
309    }
310
311    /// 是否有编辑权限
312    pub fn can_edit(&self) -> bool {
313        self.perm.can_edit()
314    }
315
316    /// 是否是所有者
317    pub fn is_owner(&self) -> bool {
318        self.perm.is_owner()
319    }
320
321    /// 是否通知了用户
322    pub fn was_notified(&self) -> bool {
323        self.notified.unwrap_or(false)
324    }
325
326    /// 是否有创建时间
327    pub fn has_create_time(&self) -> bool {
328        self.create_time.is_some()
329    }
330
331    /// 获取创建时间的格式化字符串
332    pub fn create_time_formatted(&self) -> Option<String> {
333        self.create_time
334            .map(|timestamp| format!("创建时间: {timestamp}"))
335    }
336
337    /// 获取成员类型描述
338    pub fn member_type_description(&self) -> String {
339        match self.member_type.as_str() {
340            "user" => "用户".to_string(),
341            "chat" => "群组".to_string(),
342            "department" => "部门".to_string(),
343            _ => "未知".to_string(),
344        }
345    }
346
347    /// 获取权限描述
348    pub fn permission_description(&self) -> String {
349        self.perm.description().to_string()
350    }
351
352    /// 获取摘要信息
353    pub fn summary(&self) -> String {
354        let mut parts = vec![
355            format!("{} ({})", self.member_id, self.member_type_description()),
356            format!("权限: {}", self.permission_description()),
357        ];
358
359        if let Some(time) = self.create_time_formatted() {
360            parts.push(time);
361        }
362
363        if self.was_notified() {
364            parts.push("已通知".to_string());
365        }
366
367        parts.join(", ")
368    }
369}
370
371impl CreatePermissionMemberResponse {
372    /// 获取协作者ID
373    pub fn member_id(&self) -> &str {
374        self.member.member_id()
375    }
376
377    /// 获取协作者类型
378    pub fn member_type(&self) -> &str {
379        self.member.member_type()
380    }
381
382    /// 获取权限
383    pub fn permission(&self) -> &Permission {
384        self.member.permission()
385    }
386
387    /// 是否创建成功
388    pub fn is_created(&self) -> bool {
389        !self.member.member_id.is_empty()
390    }
391
392    /// 获取创建成功摘要
393    pub fn success_summary(&self) -> String {
394        format!("协作者添加成功: {}", self.member.summary())
395    }
396
397    /// 是否通知了用户
398    pub fn was_notified(&self) -> bool {
399        self.member.was_notified()
400    }
401
402    /// 权限级别
403    pub fn permission_level(&self) -> u8 {
404        self.member.perm.level()
405    }
406}
407
408#[cfg(test)]
409#[allow(unused_variables, unused_unsafe)]
410mod tests {
411    use super::*;
412
413    #[test]
414    fn test_create_permission_member_request_builder() {
415        let request = CreatePermissionMemberRequest::builder()
416            .token("doccnxxxxxx")
417            .as_doc()
418            .user("user123")
419            .as_editor()
420            .with_notification()
421            .build();
422
423        assert_eq!(request.token, "doccnxxxxxx");
424        assert_eq!(request.obj_type, "doc");
425        assert_eq!(request.member_type, "user");
426        assert_eq!(request.member_id, "user123");
427        assert!(matches!(request.perm, Permission::Edit));
428        assert_eq!(request.need_notification, Some(true));
429    }
430
431    #[test]
432    fn test_create_permission_member_convenience_methods() {
433        let request = CreatePermissionMemberRequest::for_user(
434            "doccnxxxxxx",
435            "doc",
436            "user123",
437            Permission::Edit,
438        );
439        assert_eq!(request.member_type, "user");
440        assert_eq!(request.member_id, "user123");
441
442        let request = CreatePermissionMemberRequest::for_chat(
443            "doccnxxxxxx",
444            "doc",
445            "chat456",
446            Permission::View,
447        );
448        assert_eq!(request.member_type, "chat");
449        assert_eq!(request.member_id, "chat456");
450
451        let request = CreatePermissionMemberRequest::for_department(
452            "doccnxxxxxx",
453            "doc",
454            "dept789",
455            Permission::Comment,
456        );
457        assert_eq!(request.member_type, "department");
458        assert_eq!(request.member_id, "dept789");
459    }
460
461    #[test]
462    fn test_permission_member_created_methods() {
463        let member = PermissionMemberCreated {
464            member_type: "user".to_string(),
465            member_id: "user123".to_string(),
466            perm: Permission::Edit,
467            create_time: Some(1234567890),
468            notified: Some(true),
469        };
470
471        assert!(member.is_user());
472        assert!(!member.is_chat());
473        assert!(!member.is_department());
474        assert!(member.can_edit());
475        assert!(!member.is_owner());
476        assert!(member.was_notified());
477        assert!(member.has_create_time());
478        assert_eq!(member.member_type_description(), "用户");
479        assert_eq!(member.permission_description(), "编辑者");
480    }
481}
open_lark/service/cloud_docs/permission/member/create.rs

open_lark/service/cloud_docs/permission/member/
create.rs
