1use std::{fmt::Debug, sync::Arc};
2
3use oxinat_derive::uri_builder_alias;
4
5use crate::{UriBuilder, Version};
6
7uri_builder_alias!(SysUriBuilder);
8ImplSysUriBuilder! {
9    (String),
10    (AllowUriBuilder<'_>),
11    (CatalogsUriBuilder<'_>),
12    (DownloadUriBuilder<'_>),
13    (MessagesUriBuilder<'_>),
14    (RefreshUriBuilder<'_>),
15    (NotifyUriBuilder<'_>),
16    (SubscribersUriBuilder<'_>),
17}
18ImplSysUriBuilder! {
19    (ArchiveUriBuilder<Parent>, Parent),
20    (AsyncOpsUriBuilder<Parent>, Parent),
21    (NotificationsUriBuilder<Parent>, Parent),
22    (XnatTaskUriBuilder<Parent>, Parent),
23}
24
25#[derive(Clone, Debug, Default, UriBuilder)]
29#[match_path(path = "{parent}/archive")]
30pub struct ArchiveUriBuilder<Parent>
31where
32    Parent: SysUriBuilder,
33{
34    #[parent]
35    parent: Option<Arc<Parent>>,
36}
37
38#[derive(Clone, Debug, Default, UriBuilder)]
42#[match_path(path = "{parent}/catalogs")]
43pub struct CatalogsUriBuilder<'a>
44{
45    #[parent]
46    parent: Option<&'a ArchiveUriBuilder<String>>
47}
48
49#[derive(Clone, Debug, Default, UriBuilder)]
53#[match_path(path = "{parent}/refresh")]
54#[match_path(path = "{parent}/refresh/{operations}")]
55pub struct RefreshUriBuilder<'a>
56{
57    #[param(map_from=r#"|o: &Vec<_>| o.join(",")"#)]
58    operations: Option<Vec<String>>,
59    #[parent]
60    parent: Option<&'a CatalogsUriBuilder<'a>>,
61}
62
63impl CatalogsUriBuilder<'_>
64{
65    pub fn refresh(&self) -> RefreshUriBuilder {
68        RefreshUriBuilder::from_parent(&Arc::new(self))
69    }
70}
71
72#[derive(Clone, Debug, Default, UriBuilder)]
75#[match_path(path = "{parent}/download")]
76#[match_path(path = "{parent}/download/{catalog_id}")]
77pub struct DownloadUriBuilder<'a>
78{
79    #[param]
80    catalog_id: Option<String>,
81    #[parent]
82    parent: Option<&'a ArchiveUriBuilder<String>>
83}
84
85impl DownloadUriBuilder<'_>
86{
87    pub fn build_test(&self) -> crate::BuildResult {
91        self.build_join("test")
92    }
93
94    pub fn build_with_size(&self) -> crate::BuildResult {
97        self.parent.as_ref().unwrap().build_join("downloadwithsize")
98    }
99
100    pub fn build_xml(&self) -> crate::BuildResult {
104        self.build_join("xml")
105    }
106
107    pub fn build_zip(&self) -> crate::BuildResult {
111        self.build_join("zip")
112    }
113}
114
115impl ArchiveUriBuilder<String>
116{
117    pub fn catalogs(&self) -> CatalogsUriBuilder {
120        CatalogsUriBuilder::from_parent(&Arc::new(self))
121    }
122
123    pub fn download(&self) -> DownloadUriBuilder {
126        DownloadUriBuilder::from_parent(&Arc::new(self))
127    }
128
129    pub fn build_upload_xml(&self) -> crate::BuildResult {
132        self.build_join("upload/xml")
133    }
134}
135
136#[derive(Clone, Debug, Default, UriBuilder)]
140#[match_path(path = "{parent}/notifications")]
141pub struct NotificationsUriBuilder<Parent>
142where
143    Parent: SysUriBuilder,
144{
145    #[parent]
146    parent: Option<Arc<Parent>>
147}
148
149#[derive(Clone, Debug, Default, UriBuilder)]
153#[match_path(path = "{parent}/allow/{name}")]
154#[match_path(path = "{parent}/allow/{name}/{setting}")]
155pub struct AllowUriBuilder<'a>
156{
157    #[param]
158    name: Option<String>,
159    #[param]
160    setting: Option<String>,
161    #[parent]
162    parent: Option<&'a NotificationsUriBuilder<String>>,
163}
164
165#[derive(Clone, Debug, UriBuilder)]
168pub enum MessageType {
169    ForgotUserName,
170    Help,
171    PasswordReset,
172    Registration,
173}
174
175#[derive(Clone, Debug, Default, UriBuilder)]
178#[match_path(path = "{parent}/messages/{message_type}")]
179pub struct MessagesUriBuilder<'a>
180{
181    #[param]
182    message_type: Option<MessageType>,
183    #[parent]
184    parent: Option<&'a NotificationsUriBuilder<String>>,
185}
186
187#[derive(Clone, Debug, UriBuilder)]
190pub enum NotifyType {
191    Par,
192    Pipeline,
193    Registration,
194    Transfer,
195    Smtp,
196    #[match_path(path = "smtp/host/{p0}")]
197    SmtpHost(String),
198    #[match_path(path = "smtp/password/{p0}")]
199    SmtpPassword(String),
200    #[match_path(path = "smtp/port/{p0}")]
201    SmtpPort(String),
202    #[match_path(path = "smtp/property/{p0}")]
203    #[match_path(path = "smtp/property/{p0}/{p1}")]
204    SmtpProperty(String, Option<String>),
205    #[match_path(path = "smtp/protocol/{p0}")]
206    SmtpProtocol(String),
207    #[match_path(path = "smtp/username/{p0}")]
208    SmtpUsername(String),
209}
210
211#[derive(Clone, Debug, Default, UriBuilder)]
214#[match_path(path = "{parent}/notify/{notify_type}")]
215pub struct NotifyUriBuilder<'a>
216{
217    #[param]
218    notify_type: Option<NotifyType>,
219    #[parent]
220    parent: Option<&'a NotificationsUriBuilder<String>>,
221}
222
223#[derive(Clone, Debug, UriBuilder)]
226pub enum SubscriberOpt {
227    Error,
228    Issue,
229    NewUser,
230    Update,
231}
232
233#[derive(Clone, Debug, Default, UriBuilder)]
237#[match_path(path = "{parent}/subscribers/{subscriber_option}")]
238pub struct SubscribersUriBuilder<'a>
239{
240    #[param]
241    subscriber_option: Option<SubscriberOpt>,
242    #[parent]
243    parent: Option<&'a NotificationsUriBuilder<String>>,
244}
245
246impl NotificationsUriBuilder<String>
247{
248    pub fn allow(&self) -> AllowUriBuilder {
251        AllowUriBuilder::from_parent(&Arc::new(self))
252    }
253
254    pub fn messages(&self) -> MessagesUriBuilder {
257        MessagesUriBuilder::from_parent(&Arc::new(self))
258    }
259
260    pub fn notify(&self) -> NotifyUriBuilder {
263        NotifyUriBuilder::from_parent(&Arc::new(self))
264    }
265
266    pub fn subscribers(&self) -> SubscribersUriBuilder {
269        SubscribersUriBuilder::from_parent(&Arc::new(self))
270    }
271}
272
273#[derive(Clone, Debug, Default, UriBuilder)]
276#[match_path(path = "{parent}/xnatTask")]
277pub struct XnatTaskUriBuilder<Parent>
278where
279    Parent: SysUriBuilder,
280{
281    #[parent]
282    parent: Option<Arc<Parent>>,
283}
284
285impl XnatTaskUriBuilder<String>
286{
287    pub fn build_check_node_config_status(&self) -> crate::BuildResult {
291        self.build_join("checkNodeConfigurationStatus")
292    }
293
294    pub fn build_task_list(&self) -> crate::BuildResult {
297        self.build_join("taskList")
298    }
299}
300
301#[derive(Clone, Debug, Default, UriBuilder)]
304#[match_path(path = "{parent}/asyncOps")]
305#[match_path(path = "{parent}/asyncOps/{preference}")]
306pub struct AsyncOpsUriBuilder<Parent>
307where
308    Parent: SysUriBuilder,
309{
310    #[param]
311    preference: Option<String>,
312    #[parent]
313    parent: Option<Arc<Parent>>,
314}
315
316#[derive(Clone, Debug, UriBuilder)]
317pub enum LogConfigOpt {
318    #[match_path(path = "configs")]
319    #[match_path(path = "configs/{p0}")]
320    Configs(Option<String>),
321    #[match_path(path = "download")]
322    #[match_path(path = "download/{p0}")]
323    Download(Option<String>),
324    Elements,
325    Reset,
326}
327
328#[derive(Clone, Debug, Default, UriBuilder)]
331#[match_path(path = "{parent}/logs/{config_opt}")]
332pub struct LogsUriBuilder<Parent>
333where
334    Parent: SysUriBuilder,
335{
336    #[param]
337    config_opt: Option<LogConfigOpt>,
338    #[parent]
339    parent: Option<Arc<Parent>>,
340}
341
342pub trait SystemUri: Version {
346    #[inline]
349    fn archive(&self) -> ArchiveUriBuilder<String> {
350        ArchiveUriBuilder::from_parent(self.root_uri().into())
351    }
352
353    #[inline]
356    fn async_ops(&self) -> AsyncOpsUriBuilder<String> {
357        AsyncOpsUriBuilder::from_parent(self.root_uri().into())
358    }
359
360    #[inline]
363    fn logs(&self) -> LogsUriBuilder<String> {
364        LogsUriBuilder::from_parent(self.root_uri().into())
365    }
366
367    #[inline]
370    fn notifications(&self) -> NotificationsUriBuilder<String> {
371        NotificationsUriBuilder::from_parent(self.root_uri().into())
372    }
373
374    #[inline]
377    fn xnat_task(&self) -> XnatTaskUriBuilder<String> {
378        XnatTaskUriBuilder::from_parent(self.root_uri().into())
379    }
380}