jmap_client/sieve/
helpers.rs

1/*
2 * Copyright Stalwart Labs LLC See the COPYING
3 * file at the top-level directory of this distribution.
4 *
5 * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 * https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 * <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
8 * option. This file may not be copied, modified, or distributed
9 * except according to those terms.
10 */
11
12use crate::{
13    client::Client,
14    core::{
15        get::GetRequest,
16        query::{Comparator, Filter, QueryRequest, QueryResponse},
17        request::{Arguments, Request},
18        response::{SieveScriptGetResponse, SieveScriptSetResponse},
19        set::{SetObject, SetRequest},
20    },
21    Method, Set, URI,
22};
23
24use super::{
25    validate::{SieveScriptValidateRequest, SieveScriptValidateResponse},
26    Property, SieveScript,
27};
28
29impl Client {
30    #[maybe_async::maybe_async]
31    pub async fn sieve_script_create(
32        &self,
33        name: impl Into<String>,
34        script: impl Into<Vec<u8>>,
35        activate: bool,
36    ) -> crate::Result<SieveScript> {
37        let blob_id = self.upload(None, script.into(), None).await?.take_blob_id();
38        let mut request = self.build();
39        let set_request = request.set_sieve_script();
40        let id = set_request
41            .create()
42            .name(name)
43            .blob_id(blob_id)
44            .create_id()
45            .unwrap();
46        if activate {
47            set_request
48                .arguments()
49                .on_success_activate_script(id.clone());
50        }
51        request
52            .send_single::<SieveScriptSetResponse>()
53            .await?
54            .created(&id)
55    }
56
57    #[maybe_async::maybe_async]
58    pub async fn sieve_script_replace(
59        &self,
60        id: &str,
61        script: impl Into<Vec<u8>>,
62        activate: bool,
63    ) -> crate::Result<Option<SieveScript>> {
64        let blob_id = self.upload(None, script.into(), None).await?.take_blob_id();
65        let mut request = self.build();
66        let set_request = request.set_sieve_script();
67        set_request.update(id).blob_id(blob_id);
68        if activate {
69            set_request.arguments().on_success_activate_script_id(id);
70        }
71        request
72            .send_single::<SieveScriptSetResponse>()
73            .await?
74            .updated(id)
75    }
76
77    #[maybe_async::maybe_async]
78    pub async fn sieve_script_rename(
79        &self,
80        id: &str,
81        name: impl Into<String>,
82        activate: bool,
83    ) -> crate::Result<Option<SieveScript>> {
84        let mut request = self.build();
85        let set_request = request.set_sieve_script();
86        set_request.update(id).name(name);
87        if activate {
88            set_request.arguments().on_success_activate_script_id(id);
89        }
90        request
91            .send_single::<SieveScriptSetResponse>()
92            .await?
93            .updated(id)
94    }
95
96    #[maybe_async::maybe_async]
97    pub async fn sieve_script_activate(&self, id: &str) -> crate::Result<()> {
98        let mut request = self.build();
99        request
100            .set_sieve_script()
101            .arguments()
102            .on_success_activate_script_id(id);
103        request
104            .send_single::<SieveScriptSetResponse>()
105            .await?
106            .unwrap_update_errors()
107    }
108
109    #[maybe_async::maybe_async]
110    pub async fn sieve_script_deactivate(&self) -> crate::Result<()> {
111        let mut request = self.build();
112        request
113            .set_sieve_script()
114            .arguments()
115            .on_success_deactivate_script(true);
116        request
117            .send_single::<SieveScriptSetResponse>()
118            .await?
119            .unwrap_update_errors()
120    }
121
122    #[maybe_async::maybe_async]
123    pub async fn sieve_script_destroy(&self, id: &str) -> crate::Result<()> {
124        let mut request = self.build();
125        request.set_sieve_script().destroy([id]);
126        request
127            .send_single::<SieveScriptSetResponse>()
128            .await?
129            .destroyed(id)
130    }
131
132    #[maybe_async::maybe_async]
133    pub async fn sieve_script_get(
134        &self,
135        id: &str,
136        properties: Option<impl IntoIterator<Item = Property>>,
137    ) -> crate::Result<Option<SieveScript>> {
138        let mut request = self.build();
139        let get_request = request.get_sieve_script().ids([id]);
140        if let Some(properties) = properties {
141            get_request.properties(properties.into_iter());
142        }
143        request
144            .send_single::<SieveScriptGetResponse>()
145            .await
146            .map(|mut r| r.take_list().pop())
147    }
148
149    #[maybe_async::maybe_async]
150    pub async fn sieve_script_query(
151        &self,
152        filter: Option<impl Into<Filter<super::query::Filter>>>,
153        sort: Option<impl IntoIterator<Item = Comparator<super::query::Comparator>>>,
154    ) -> crate::Result<QueryResponse> {
155        let mut request = self.build();
156        let query_request = request.query_sieve_script();
157        if let Some(filter) = filter {
158            query_request.filter(filter);
159        }
160        if let Some(sort) = sort {
161            query_request.sort(sort.into_iter());
162        }
163        request.send_single::<QueryResponse>().await
164    }
165
166    #[maybe_async::maybe_async]
167    pub async fn sieve_script_validate(&self, script: impl Into<Vec<u8>>) -> crate::Result<()> {
168        let blob_id = self.upload(None, script.into(), None).await?.take_blob_id();
169        let mut request = self.build();
170        request.validate_sieve_script(blob_id);
171        request
172            .send_single::<SieveScriptValidateResponse>()
173            .await?
174            .unwrap_error()
175    }
176}
177
178impl Request<'_> {
179    pub fn get_sieve_script(&mut self) -> &mut GetRequest<SieveScript<Set>> {
180        self.add_capability(URI::Sieve);
181        self.add_method_call(
182            Method::GetSieveScript,
183            Arguments::sieve_script_get(self.params(Method::GetSieveScript)),
184        )
185        .sieve_script_get_mut()
186    }
187
188    #[maybe_async::maybe_async]
189    pub async fn send_get_sieve_script(self) -> crate::Result<SieveScriptGetResponse> {
190        self.send_single().await
191    }
192
193    pub fn set_sieve_script(&mut self) -> &mut SetRequest<SieveScript<Set>> {
194        self.add_capability(URI::Sieve);
195        self.add_method_call(
196            Method::SetSieveScript,
197            Arguments::sieve_script_set(self.params(Method::SetSieveScript)),
198        )
199        .sieve_script_set_mut()
200    }
201
202    #[maybe_async::maybe_async]
203    pub async fn send_set_sieve_script(self) -> crate::Result<SieveScriptSetResponse> {
204        self.send_single().await
205    }
206
207    pub fn validate_sieve_script(
208        &mut self,
209        blob_id: impl Into<String>,
210    ) -> &mut SieveScriptValidateRequest {
211        self.add_capability(URI::Sieve);
212        self.add_method_call(
213            Method::ValidateSieveScript,
214            Arguments::sieve_script_validate(self.params(Method::ValidateSieveScript), blob_id),
215        )
216        .sieve_script_validate_mut()
217    }
218
219    #[maybe_async::maybe_async]
220    pub async fn send_validate_sieve_script(self) -> crate::Result<SieveScriptValidateResponse> {
221        self.send_single().await
222    }
223
224    pub fn query_sieve_script(&mut self) -> &mut QueryRequest<SieveScript<Set>> {
225        self.add_capability(URI::Sieve);
226        self.add_method_call(
227            Method::QuerySieveScript,
228            Arguments::sieve_script_query(self.params(Method::QuerySieveScript)),
229        )
230        .sieve_script_query_mut()
231    }
232
233    #[maybe_async::maybe_async]
234    pub async fn send_query_sieve_script(self) -> crate::Result<QueryResponse> {
235        self.send_single().await
236    }
237}
jmap_client/sieve/helpers.rs

jmap_client/sieve/
helpers.rs
