Skip to main content

conductor/models/
authorization.rs

1// Copyright {{.Year}} Conductor OSS
2// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3
4use serde::{Deserialize, Serialize};
5use std::collections::HashMap;
6
7/// Conductor user.
8#[derive(Debug, Clone, Default, Serialize, Deserialize)]
9#[serde(rename_all = "camelCase")]
10pub struct ConductorUser {
11    /// User ID.
12    pub id: String,
13
14    /// User name.
15    #[serde(skip_serializing_if = "Option::is_none")]
16    pub name: Option<String>,
17
18    /// User email.
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub email: Option<String>,
21
22    /// Roles assigned to the user.
23    #[serde(default)]
24    pub roles: Vec<Role>,
25
26    /// Groups the user belongs to.
27    #[serde(default)]
28    pub groups: Vec<Group>,
29
30    /// Is application user.
31    #[serde(default)]
32    pub application_user: bool,
33}
34
35/// Upsert user request.
36#[derive(Debug, Clone, Default, Serialize, Deserialize)]
37#[serde(rename_all = "camelCase")]
38pub struct UpsertUserRequest {
39    /// User name.
40    pub name: String,
41
42    /// User email (optional for app users).
43    #[serde(skip_serializing_if = "Option::is_none")]
44    pub email: Option<String>,
45
46    /// Roles to assign.
47    #[serde(default)]
48    pub roles: Vec<String>,
49
50    /// Groups to add user to.
51    #[serde(default)]
52    pub groups: Vec<String>,
53}
54
55impl UpsertUserRequest {
56    /// Create a new upsert user request.
57    pub fn new(name: impl Into<String>) -> Self {
58        Self {
59            name: name.into(),
60            ..Default::default()
61        }
62    }
63
64    /// Set email.
65    #[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    /// Add roles.
72    #[must_use]
73    pub fn with_roles(mut self, roles: Vec<String>) -> Self {
74        self.roles = roles;
75        self
76    }
77
78    /// Add groups.
79    #[must_use]
80    pub fn with_groups(mut self, groups: Vec<String>) -> Self {
81        self.groups = groups;
82        self
83    }
84}
85
86/// User group.
87#[derive(Debug, Clone, Default, Serialize, Deserialize)]
88#[serde(rename_all = "camelCase")]
89pub struct Group {
90    /// Group ID.
91    pub id: String,
92
93    /// Group name.
94    #[serde(skip_serializing_if = "Option::is_none")]
95    pub name: Option<String>,
96
97    /// Group description.
98    #[serde(skip_serializing_if = "Option::is_none")]
99    pub description: Option<String>,
100
101    /// Roles assigned to the group.
102    #[serde(default)]
103    pub roles: Vec<Role>,
104
105    /// Default access for group.
106    #[serde(default)]
107    pub default_access: HashMap<String, Vec<String>>,
108}
109
110/// Upsert group request.
111#[derive(Debug, Clone, Default, Serialize, Deserialize)]
112#[serde(rename_all = "camelCase")]
113pub struct UpsertGroupRequest {
114    /// Group name.
115    pub name: String,
116
117    /// Group description.
118    #[serde(skip_serializing_if = "Option::is_none")]
119    pub description: Option<String>,
120
121    /// Roles to assign.
122    #[serde(default)]
123    pub roles: Vec<String>,
124
125    /// Default access permissions.
126    #[serde(default)]
127    pub default_access: HashMap<String, Vec<String>>,
128}
129
130impl UpsertGroupRequest {
131    /// Create a new upsert group request.
132    pub fn new(name: impl Into<String>) -> Self {
133        Self {
134            name: name.into(),
135            ..Default::default()
136        }
137    }
138
139    /// Set description.
140    #[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    /// Add roles.
147    #[must_use]
148    pub fn with_roles(mut self, roles: Vec<String>) -> Self {
149        self.roles = roles;
150        self
151    }
152}
153
154/// Role definition.
155#[derive(Debug, Clone, Default, Serialize, Deserialize)]
156#[serde(rename_all = "camelCase")]
157pub struct Role {
158    /// Role name.
159    pub name: String,
160
161    /// Role permissions.
162    #[serde(default)]
163    pub permissions: Vec<Permission>,
164}
165
166/// Permission.
167#[derive(Debug, Clone, Default, Serialize, Deserialize)]
168#[serde(rename_all = "camelCase")]
169pub struct Permission {
170    /// Permission name.
171    pub name: String,
172}
173
174/// Conductor application.
175#[derive(Debug, Clone, Default, Serialize, Deserialize)]
176#[serde(rename_all = "camelCase")]
177pub struct ConductorApplication {
178    /// Application ID.
179    pub id: String,
180
181    /// Application name.
182    pub name: String,
183
184    /// Create time.
185    #[serde(skip_serializing_if = "Option::is_none")]
186    pub create_time: Option<i64>,
187
188    /// Created by.
189    #[serde(skip_serializing_if = "Option::is_none")]
190    pub created_by: Option<String>,
191
192    /// Update time.
193    #[serde(skip_serializing_if = "Option::is_none")]
194    pub update_time: Option<i64>,
195
196    /// Updated by.
197    #[serde(skip_serializing_if = "Option::is_none")]
198    pub updated_by: Option<String>,
199}
200
201/// Create or update application request.
202#[derive(Debug, Clone, Default, Serialize, Deserialize)]
203#[serde(rename_all = "camelCase")]
204pub struct CreateOrUpdateApplicationRequest {
205    /// Application name.
206    pub name: String,
207}
208
209impl CreateOrUpdateApplicationRequest {
210    /// Create a new request.
211    pub fn new(name: impl Into<String>) -> Self {
212        Self { name: name.into() }
213    }
214}
215
216/// Access key for application.
217#[derive(Debug, Clone, Default, Serialize, Deserialize)]
218#[serde(rename_all = "camelCase")]
219pub struct AccessKey {
220    /// Key ID.
221    pub id: String,
222
223    /// Key status.
224    pub status: String,
225
226    /// Create time.
227    #[serde(skip_serializing_if = "Option::is_none")]
228    pub create_time: Option<i64>,
229
230    /// Created by.
231    #[serde(skip_serializing_if = "Option::is_none")]
232    pub created_by: Option<String>,
233}
234
235/// Created access key (includes secret, only returned on creation)
236///
237/// Note: unlike `AccessKey`, the server's create-access-key response
238/// (`POST /applications/{id}/accessKeys`) never includes a `status` field --
239/// it's only present on the list/toggle responses (`AccessKey`) -- so it's
240/// intentionally omitted here rather than left as a required field that
241/// would fail to deserialize.
242#[derive(Debug, Clone, Default, Serialize, Deserialize)]
243#[serde(rename_all = "camelCase")]
244pub struct CreatedAccessKey {
245    /// Key ID.
246    pub id: String,
247
248    /// Key secret (only available on creation).
249    pub secret: String,
250}
251
252/// Subject reference (user or group).
253#[derive(Debug, Clone, Serialize, Deserialize)]
254#[serde(rename_all = "camelCase")]
255pub struct SubjectRef {
256    /// Subject type (USER or GROUP).
257    #[serde(rename = "type")]
258    pub subject_type: SubjectType,
259
260    /// Subject ID.
261    pub id: String,
262}
263
264impl SubjectRef {
265    /// Create a user subject reference.
266    pub fn user(id: impl Into<String>) -> Self {
267        Self {
268            subject_type: SubjectType::User,
269            id: id.into(),
270        }
271    }
272
273    /// Create a group subject reference.
274    pub fn group(id: impl Into<String>) -> Self {
275        Self {
276            subject_type: SubjectType::Group,
277            id: id.into(),
278        }
279    }
280}
281
282/// Subject type.
283#[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/// Target reference (resource being accessed).
291#[derive(Debug, Clone, Serialize, Deserialize)]
292#[serde(rename_all = "camelCase")]
293pub struct TargetRef {
294    /// Target type.
295    #[serde(rename = "type")]
296    pub target_type: TargetType,
297
298    /// Target ID.
299    pub id: String,
300}
301
302impl TargetRef {
303    /// Create a workflow definition target.
304    pub fn workflow(name: impl Into<String>) -> Self {
305        Self {
306            target_type: TargetType::WorkflowDef,
307            id: name.into(),
308        }
309    }
310
311    /// Create a task definition target.
312    pub fn task(name: impl Into<String>) -> Self {
313        Self {
314            target_type: TargetType::TaskDef,
315            id: name.into(),
316        }
317    }
318
319    /// Create a secret target.
320    pub fn secret(name: impl Into<String>) -> Self {
321        Self {
322            target_type: TargetType::Secret,
323            id: name.into(),
324        }
325    }
326
327    /// Create a domain target.
328    pub fn domain(name: impl Into<String>) -> Self {
329        Self {
330            target_type: TargetType::Domain,
331            id: name.into(),
332        }
333    }
334}
335
336/// Target type.
337#[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/// Access type.
349#[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/// Granted permission.
360#[derive(Debug, Clone, Default, Serialize, Deserialize)]
361#[serde(rename_all = "camelCase")]
362pub struct GrantedPermission {
363    /// Target.
364    pub target: Option<TargetRef>,
365
366    /// Access types granted.
367    #[serde(default)]
368    pub access: Vec<AccessType>,
369
370    /// Tag the grant was made through, when the grant came from a tag rather
371    /// than a direct target (server-side `GrantedAccess.tag`)
372    #[serde(skip_serializing_if = "Option::is_none")]
373    pub tag: Option<String>,
374}