1use serde::{Deserialize, Serialize};
5use std::collections::HashMap;
6
7#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9#[serde(rename_all = "camelCase")]
10pub struct ConductorUser {
11 pub id: String,
13
14 #[serde(skip_serializing_if = "Option::is_none")]
16 pub name: Option<String>,
17
18 #[serde(skip_serializing_if = "Option::is_none")]
20 pub email: Option<String>,
21
22 #[serde(default)]
24 pub roles: Vec<Role>,
25
26 #[serde(default)]
28 pub groups: Vec<Group>,
29
30 #[serde(default)]
32 pub application_user: bool,
33}
34
35#[derive(Debug, Clone, Default, Serialize, Deserialize)]
37#[serde(rename_all = "camelCase")]
38pub struct UpsertUserRequest {
39 pub name: String,
41
42 #[serde(skip_serializing_if = "Option::is_none")]
44 pub email: Option<String>,
45
46 #[serde(default)]
48 pub roles: Vec<String>,
49
50 #[serde(default)]
52 pub groups: Vec<String>,
53}
54
55impl UpsertUserRequest {
56 pub fn new(name: impl Into<String>) -> Self {
58 Self {
59 name: name.into(),
60 ..Default::default()
61 }
62 }
63
64 #[must_use]
66 pub fn with_email(mut self, email: impl Into<String>) -> Self {
67 self.email = Some(email.into());
68 self
69 }
70
71 #[must_use]
73 pub fn with_roles(mut self, roles: Vec<String>) -> Self {
74 self.roles = roles;
75 self
76 }
77
78 #[must_use]
80 pub fn with_groups(mut self, groups: Vec<String>) -> Self {
81 self.groups = groups;
82 self
83 }
84}
85
86#[derive(Debug, Clone, Default, Serialize, Deserialize)]
88#[serde(rename_all = "camelCase")]
89pub struct Group {
90 pub id: String,
92
93 #[serde(skip_serializing_if = "Option::is_none")]
95 pub name: Option<String>,
96
97 #[serde(skip_serializing_if = "Option::is_none")]
99 pub description: Option<String>,
100
101 #[serde(default)]
103 pub roles: Vec<Role>,
104
105 #[serde(default)]
107 pub default_access: HashMap<String, Vec<String>>,
108}
109
110#[derive(Debug, Clone, Default, Serialize, Deserialize)]
112#[serde(rename_all = "camelCase")]
113pub struct UpsertGroupRequest {
114 pub name: String,
116
117 #[serde(skip_serializing_if = "Option::is_none")]
119 pub description: Option<String>,
120
121 #[serde(default)]
123 pub roles: Vec<String>,
124
125 #[serde(default)]
127 pub default_access: HashMap<String, Vec<String>>,
128}
129
130impl UpsertGroupRequest {
131 pub fn new(name: impl Into<String>) -> Self {
133 Self {
134 name: name.into(),
135 ..Default::default()
136 }
137 }
138
139 #[must_use]
141 pub fn with_description(mut self, description: impl Into<String>) -> Self {
142 self.description = Some(description.into());
143 self
144 }
145
146 #[must_use]
148 pub fn with_roles(mut self, roles: Vec<String>) -> Self {
149 self.roles = roles;
150 self
151 }
152}
153
154#[derive(Debug, Clone, Default, Serialize, Deserialize)]
156#[serde(rename_all = "camelCase")]
157pub struct Role {
158 pub name: String,
160
161 #[serde(default)]
163 pub permissions: Vec<Permission>,
164}
165
166#[derive(Debug, Clone, Default, Serialize, Deserialize)]
168#[serde(rename_all = "camelCase")]
169pub struct Permission {
170 pub name: String,
172}
173
174#[derive(Debug, Clone, Default, Serialize, Deserialize)]
176#[serde(rename_all = "camelCase")]
177pub struct ConductorApplication {
178 pub id: String,
180
181 pub name: String,
183
184 #[serde(skip_serializing_if = "Option::is_none")]
186 pub create_time: Option<i64>,
187
188 #[serde(skip_serializing_if = "Option::is_none")]
190 pub created_by: Option<String>,
191
192 #[serde(skip_serializing_if = "Option::is_none")]
194 pub update_time: Option<i64>,
195
196 #[serde(skip_serializing_if = "Option::is_none")]
198 pub updated_by: Option<String>,
199}
200
201#[derive(Debug, Clone, Default, Serialize, Deserialize)]
203#[serde(rename_all = "camelCase")]
204pub struct CreateOrUpdateApplicationRequest {
205 pub name: String,
207}
208
209impl CreateOrUpdateApplicationRequest {
210 pub fn new(name: impl Into<String>) -> Self {
212 Self { name: name.into() }
213 }
214}
215
216#[derive(Debug, Clone, Default, Serialize, Deserialize)]
218#[serde(rename_all = "camelCase")]
219pub struct AccessKey {
220 pub id: String,
222
223 pub status: String,
225
226 #[serde(skip_serializing_if = "Option::is_none")]
228 pub create_time: Option<i64>,
229
230 #[serde(skip_serializing_if = "Option::is_none")]
232 pub created_by: Option<String>,
233}
234
235#[derive(Debug, Clone, Default, Serialize, Deserialize)]
243#[serde(rename_all = "camelCase")]
244pub struct CreatedAccessKey {
245 pub id: String,
247
248 pub secret: String,
250}
251
252#[derive(Debug, Clone, Serialize, Deserialize)]
254#[serde(rename_all = "camelCase")]
255pub struct SubjectRef {
256 #[serde(rename = "type")]
258 pub subject_type: SubjectType,
259
260 pub id: String,
262}
263
264impl SubjectRef {
265 pub fn user(id: impl Into<String>) -> Self {
267 Self {
268 subject_type: SubjectType::User,
269 id: id.into(),
270 }
271 }
272
273 pub fn group(id: impl Into<String>) -> Self {
275 Self {
276 subject_type: SubjectType::Group,
277 id: id.into(),
278 }
279 }
280}
281
282#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
284#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
285pub enum SubjectType {
286 User,
287 Group,
288}
289
290#[derive(Debug, Clone, Serialize, Deserialize)]
292#[serde(rename_all = "camelCase")]
293pub struct TargetRef {
294 #[serde(rename = "type")]
296 pub target_type: TargetType,
297
298 pub id: String,
300}
301
302impl TargetRef {
303 pub fn workflow(name: impl Into<String>) -> Self {
305 Self {
306 target_type: TargetType::WorkflowDef,
307 id: name.into(),
308 }
309 }
310
311 pub fn task(name: impl Into<String>) -> Self {
313 Self {
314 target_type: TargetType::TaskDef,
315 id: name.into(),
316 }
317 }
318
319 pub fn secret(name: impl Into<String>) -> Self {
321 Self {
322 target_type: TargetType::Secret,
323 id: name.into(),
324 }
325 }
326
327 pub fn domain(name: impl Into<String>) -> Self {
329 Self {
330 target_type: TargetType::Domain,
331 id: name.into(),
332 }
333 }
334}
335
336#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
338#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
339pub enum TargetType {
340 WorkflowDef,
341 TaskDef,
342 Secret,
343 Domain,
344 Tag,
345 Integration,
346}
347
348#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
350#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
351pub enum AccessType {
352 Create,
353 Read,
354 Update,
355 Delete,
356 Execute,
357}
358
359#[derive(Debug, Clone, Default, Serialize, Deserialize)]
361#[serde(rename_all = "camelCase")]
362pub struct GrantedPermission {
363 pub target: Option<TargetRef>,
365
366 #[serde(default)]
368 pub access: Vec<AccessType>,
369
370 #[serde(skip_serializing_if = "Option::is_none")]
373 pub tag: Option<String>,
374}