open_lark/service/cloud_docs/bitable/v1/app_role_member/
create.rs1use reqwest::Method;
2use serde::{Deserialize, Serialize};
3
4use crate::{
5 core::{
6 api_req::ApiRequest,
7 api_resp::{ApiResponseTrait, BaseResponse, ResponseFormat},
8 constants::AccessTokenType,
9 http::Transport,
10 req_option::RequestOption,
11 SDKResult,
12 },
13 impl_executable_builder_owned,
14};
15
16use super::AppRoleMemberService;
17
18impl AppRoleMemberService {
19 pub async fn create(
21 &self,
22 request: CreateRoleMemberRequest,
23 option: Option<RequestOption>,
24 ) -> SDKResult<BaseResponse<CreateRoleMemberResponse>> {
25 let mut api_req = request.api_request;
26 api_req.http_method = Method::POST;
27 api_req.api_path = format!(
28 "/open-apis/bitable/v1/apps/{app_token}/roles/{role_id}/members",
29 app_token = request.app_token,
30 role_id = request.role_id
31 );
32 api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
33
34 let api_resp = Transport::request(api_req, &self.config, option).await?;
35 Ok(api_resp)
36 }
37}
38
39#[derive(Debug, Serialize, Default)]
41pub struct CreateRoleMemberRequest {
42 #[serde(skip)]
43 api_request: ApiRequest,
44 #[serde(skip)]
46 app_token: String,
47 #[serde(skip)]
49 role_id: String,
50 #[serde(skip)]
52 user_id_type: Option<String>,
53 member_id: String,
55 member_type: String,
57}
58
59impl CreateRoleMemberRequest {
60 pub fn builder() -> CreateRoleMemberRequestBuilder {
61 CreateRoleMemberRequestBuilder::default()
62 }
63
64 pub fn new(
65 app_token: impl ToString,
66 role_id: impl ToString,
67 member_id: impl ToString,
68 member_type: impl ToString,
69 ) -> Self {
70 Self {
71 app_token: app_token.to_string(),
72 role_id: role_id.to_string(),
73 member_id: member_id.to_string(),
74 member_type: member_type.to_string(),
75 ..Default::default()
76 }
77 }
78}
79
80#[derive(Default)]
81pub struct CreateRoleMemberRequestBuilder {
82 request: CreateRoleMemberRequest,
83}
84
85impl CreateRoleMemberRequestBuilder {
86 pub fn app_token(mut self, app_token: impl ToString) -> Self {
88 self.request.app_token = app_token.to_string();
89 self
90 }
91
92 pub fn role_id(mut self, role_id: impl ToString) -> Self {
94 self.request.role_id = role_id.to_string();
95 self
96 }
97
98 pub fn user_id_type(mut self, user_id_type: impl ToString) -> Self {
100 self.request.user_id_type = Some(user_id_type.to_string());
101 self
102 }
103
104 pub fn member_id(mut self, member_id: impl ToString) -> Self {
106 self.request.member_id = member_id.to_string();
107 self
108 }
109
110 pub fn member_type(mut self, member_type: impl ToString) -> Self {
112 self.request.member_type = member_type.to_string();
113 self
114 }
115
116 pub fn build(mut self) -> CreateRoleMemberRequest {
117 if let Some(user_id_type) = &self.request.user_id_type {
118 self.request
119 .api_request
120 .query_params
121 .insert("user_id_type".to_string(), user_id_type.clone());
122 }
123 self.request.api_request.body = serde_json::to_vec(&self.request).unwrap();
124 self.request
125 }
126}
127
128impl_executable_builder_owned!(
129 CreateRoleMemberRequestBuilder,
130 AppRoleMemberService,
131 CreateRoleMemberRequest,
132 BaseResponse<CreateRoleMemberResponse>,
133 create
134);
135
136#[derive(Debug, Deserialize)]
138pub struct RoleMember {
139 pub member_id: String,
141 pub member_type: String,
143 pub member_name: Option<String>,
145}
146
147#[derive(Debug, Deserialize)]
149pub struct CreateRoleMemberResponse {
150 pub member: RoleMember,
152}
153
154impl ApiResponseTrait for CreateRoleMemberResponse {
155 fn data_format() -> ResponseFormat {
156 ResponseFormat::Data
157 }
158}
159
160#[cfg(test)]
161mod tests {
162 use super::*;
163
164 #[test]
165 fn test_create_role_member_request_builder() {
166 let request = CreateRoleMemberRequest::builder()
167 .app_token("bascnmBA*****yGehy8")
168 .role_id("rolxxxxxx")
169 .member_id("ou_xxxxxx")
170 .member_type("user")
171 .user_id_type("open_id")
172 .build();
173
174 assert_eq!(request.app_token, "bascnmBA*****yGehy8");
175 assert_eq!(request.role_id, "rolxxxxxx");
176 assert_eq!(request.member_id, "ou_xxxxxx");
177 assert_eq!(request.member_type, "user");
178 assert_eq!(request.user_id_type, Some("open_id".to_string()));
179 }
180}