1use crate::{PublicName, PublicUuid, refs::SessionSelector};
2use chrono::{DateTime, Utc};
3use serde::{Deserialize, Serialize};
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6#[serde(rename_all = "snake_case")]
7pub enum SessionStatus {
8 Opening,
9 Open,
10 Closed,
11 Unavailable,
12}
13
14#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
15pub struct SessionSummary {
16 pub session: crate::refs::SessionRef,
17 pub status: SessionStatus,
18 #[serde(default, skip_serializing_if = "Option::is_none")]
19 pub current_study: Option<crate::refs::ObjectRef>,
20}
21
22#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
23pub struct RestrictedLocalPath {
24 pub path: String,
25}
26
27#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
28#[serde(deny_unknown_fields)]
29pub struct SessionListRequest {
30 #[serde(default)]
31 pub include_unavailable: bool,
32}
33
34#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
37#[serde(deny_unknown_fields)]
38pub struct SessionOpenRequest {
39 pub name: PublicName,
40 #[serde(default, skip_serializing_if = "Option::is_none")]
41 pub execution_profile: Option<String>,
42}
43
44#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
45#[serde(deny_unknown_fields)]
46pub struct SessionStatusRequest {
47 #[serde(default, skip_serializing_if = "Option::is_none")]
48 pub session: Option<SessionSelector>,
49}
50
51#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
52#[serde(deny_unknown_fields)]
53pub struct SessionUseRequest {
54 pub session: SessionSelector,
55}
56
57#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
58#[serde(deny_unknown_fields)]
59pub struct SessionCloseRequest {
60 pub session: SessionSelector,
61}
62
63#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
64#[serde(deny_unknown_fields)]
65pub struct SessionCloseAllRequest {}
66
67#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
68#[serde(deny_unknown_fields)]
69pub struct CurrentStudySetRequest {
70 #[serde(default, skip_serializing_if = "Option::is_none")]
71 pub session: Option<SessionSelector>,
72 pub study: crate::refs::ObjectSelector,
73 #[serde(default, skip_serializing_if = "Option::is_none")]
74 pub domain: Option<crate::refs::ObjectSelector>,
75}
76
77#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
78#[serde(deny_unknown_fields)]
79pub struct CurrentStudyCurrentRequest {
80 #[serde(default, skip_serializing_if = "Option::is_none")]
81 pub session: Option<SessionSelector>,
82}
83
84#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
85#[serde(deny_unknown_fields)]
86pub struct CurrentStudyClearRequest {
87 #[serde(default, skip_serializing_if = "Option::is_none")]
88 pub session: Option<SessionSelector>,
89}
90
91#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
92#[serde(deny_unknown_fields)]
93pub struct StudyContextListRequest {
94 #[serde(default)]
95 pub include_unavailable: bool,
96}
97
98#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
99#[serde(rename_all = "snake_case")]
100pub enum SessionAvailability {
101 Live,
102 PersistedOnly,
103 Unavailable,
104 Stale,
105 Missing,
106 Closed,
107}
108
109#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
110pub struct DatastoreIdentity {
111 pub server: String,
112 pub port: u16,
113 #[serde(default, skip_serializing_if = "Option::is_none")]
114 pub datastore: Option<String>,
115 #[serde(default, skip_serializing_if = "Option::is_none")]
116 pub sslmode: Option<String>,
117 #[serde(default, skip_serializing_if = "Option::is_none")]
118 pub lake_data: Option<RestrictedLocalPath>,
119 #[serde(default, skip_serializing_if = "Option::is_none")]
120 pub lake_db: Option<RestrictedLocalPath>,
121 #[serde(default, skip_serializing_if = "Option::is_none")]
122 pub catalog_schema: Option<String>,
123}
124
125#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
126#[serde(deny_unknown_fields)]
127pub struct SessionStatusPayload {
128 #[serde(default, skip_serializing_if = "Vec::is_empty")]
129 pub adapter_observations: Vec<crate::diagnostics::DiagnosticFinding>,
130 pub session: Option<crate::refs::SessionRef>,
131 pub name: String,
132 #[serde(default, skip_serializing_if = "Option::is_none")]
133 pub execution_profile: Option<String>,
134 #[serde(default, skip_serializing_if = "Option::is_none")]
135 pub datastore_key: Option<String>,
136 #[serde(default, skip_serializing_if = "Option::is_none")]
137 pub datastore_id: Option<PublicUuid>,
138 pub availability: SessionAvailability,
139 #[serde(default, skip_serializing_if = "Option::is_none")]
140 pub authenticated_tre_user: Option<String>,
141 #[serde(default, skip_serializing_if = "Option::is_none")]
142 pub current_study: Option<crate::refs::ObjectRef>,
143 #[serde(default, skip_serializing_if = "Option::is_none")]
144 pub current_study_name: Option<String>,
145 #[serde(default, skip_serializing_if = "Option::is_none")]
146 pub created_at: Option<DateTime<Utc>>,
147 #[serde(default, skip_serializing_if = "Option::is_none")]
148 pub updated_at: Option<DateTime<Utc>>,
149 #[serde(default, skip_serializing_if = "Option::is_none")]
150 pub unavailable_reason: Option<String>,
151}
152
153#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
154pub struct SessionStatusResponse {
155 pub session: SessionStatusPayload,
156}
157
158#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
159pub struct SessionOpenResponse {
160 pub session: SessionStatusPayload,
161}
162
163#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
164pub struct SessionListResponse {
165 pub selected_session: Option<crate::refs::SessionRef>,
166 pub sessions: Vec<SessionStatusPayload>,
167}
168
169#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
170pub struct SessionUseResponse {
171 pub session: SessionStatusPayload,
172}
173
174#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
175pub struct SessionCloseResponse {
176 pub session: SessionStatusPayload,
177}
178
179#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
180pub struct SessionCloseAllResponse {
181 pub complete: bool,
182 pub outcomes: Vec<SessionCloseOutcome>,
183 pub selected_session: Option<crate::refs::SessionRef>,
184}
185
186#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
187#[serde(rename_all = "snake_case")]
188pub enum SessionCloseDisposition {
189 Closed,
190 Absent,
191 Failed,
192 Unknown,
193 NotAttempted,
194}
195
196#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
197pub struct SessionCloseOutcome {
198 pub session: crate::refs::SessionRef,
199 pub outcome: SessionCloseDisposition,
200 pub error: Option<crate::ProtocolError>,
201 pub local_error: Option<crate::ProtocolError>,
202}
203
204#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
205pub struct CurrentStudyResponse {
206 pub session: SessionStatusPayload,
207 #[serde(default, skip_serializing_if = "Option::is_none")]
208 pub current_study: Option<crate::refs::ObjectRef>,
209 #[serde(default, skip_serializing_if = "Option::is_none")]
210 pub current_study_name: Option<String>,
211}
212
213#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
214pub struct StudyContextPayload {
215 pub session: SessionStatusPayload,
216 #[serde(default, skip_serializing_if = "Option::is_none")]
217 pub current_study: Option<crate::refs::ObjectRef>,
218 #[serde(default, skip_serializing_if = "Option::is_none")]
219 pub current_study_name: Option<String>,
220}
221
222#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
223pub struct StudyContextListResponse {
224 pub contexts: Vec<StudyContextPayload>,
225 pub selected_session: Option<crate::refs::SessionRef>,
226}