Struct Response

Source

pub struct Response<T> { /* private fields */ }

Implementations§

Source §

impl<T> Response<T>

Source

pub fn new( method_responses: Vec<T>, created_ids: Option<AHashMap<String, String>>, session_state: String, request_id: Option<String>, ) -> Self

Source

pub fn method_responses(&self) -> &[T]

Source

pub fn unwrap_method_responses(self) -> Vec<T>

Examples found in repository ?

examples/result_reference.rs (line 42)

20async fn result_reference() {
21    // Connect to the JMAP server using Basic authentication
22    let client = Client::new()
23        .credentials(("john@example.org", "secret"))
24        .connect("https://jmap.example.org")
25        .await
26        .unwrap();
27
28    // Delete e-mails matching a filter
29    let mut request = client.build();
30    let result_ref = request
31        .query_email()
32        .filter(query::Filter::and([
33            email::query::Filter::has_keyword("$draft"),
34            email::query::Filter::from("bill"),
35        ]))
36        .result_reference();
37    request.set_email().destroy_ref(result_ref);
38    let _destroyed_ids = request
39        .send()
40        .await
41        .unwrap()
42        .unwrap_method_responses()
43        .pop()
44        .unwrap()
45        .unwrap_set_email()
46        .unwrap()
47        .take_destroyed_ids();
48
49    // Fetch mailboxes matching a filter
50    let mut request = client.build();
51    let query_result = request
52        .query_mailbox()
53        .filter(query::Filter::and([
54            mailbox::query::Filter::has_any_role(false),
55            mailbox::query::Filter::is_subscribed(true),
56        ]))
57        .result_reference();
58    request.get_mailbox().ids_ref(query_result).properties([
59        mailbox::Property::Id,
60        mailbox::Property::Name,
61        mailbox::Property::ParentId,
62        mailbox::Property::TotalEmails,
63        mailbox::Property::UnreadEmails,
64    ]);
65    let _mailboxes = request
66        .send()
67        .await
68        .unwrap()
69        .unwrap_method_responses()
70        .pop()
71        .unwrap()
72        .unwrap_get_mailbox()
73        .unwrap()
74        .take_list();
75
76    // Fetch only the updated properties of all mailboxes that changed
77    // since a state.
78    let mut request = client.build();
79    let changes_request = request.changes_mailbox("n").max_changes(0);
80    let properties_ref = changes_request.updated_properties_reference();
81    let updated_ref = changes_request.updated_reference();
82    request
83        .get_mailbox()
84        .ids_ref(updated_ref)
85        .properties_ref(properties_ref);
86    for mailbox in request
87        .send()
88        .await
89        .unwrap()
90        .unwrap_method_responses()
91        .pop()
92        .unwrap()
93        .unwrap_get_mailbox()
94        .unwrap()
95        .take_list()
96    {
97        println!("Changed mailbox: {:#?}", mailbox);
98    }
99}

Source

pub fn method_response_by_pos(&mut self, index: usize) -> T

Source

pub fn pop_method_response(&mut self) -> Option<T>

Examples found in repository ?

examples/websocket.rs (line 59)

25async fn websocket() {
26    // Connect to the JMAP server using Basic authentication
27    let client = Client::new()
28        .credentials(("john@example.org", "secret"))
29        .connect("https://jmap.example.org")
30        .await
31        .unwrap();
32
33    // Connect to the WebSocket endpoint
34    let mut ws_stream = client.connect_ws().await.unwrap();
35
36    // Read WS messages on a separate thread
37    let (stream_tx, mut stream_rx) = mpsc::channel::<WebSocketMessage>(100);
38    tokio::spawn(async move {
39        while let Some(change) = ws_stream.next().await {
40            stream_tx.send(change.unwrap()).await.unwrap();
41        }
42    });
43
44    // Create a mailbox over WS
45    let mut request = client.build();
46    let create_id = request
47        .set_mailbox()
48        .create()
49        .name("WebSocket Test")
50        .create_id()
51        .unwrap();
52    let request_id = request.send_ws().await.unwrap();
53
54    // Read response from WS stream
55    let mailbox_id = if let Some(WebSocketMessage::Response(mut response)) = stream_rx.recv().await
56    {
57        assert_eq!(request_id, response.request_id().unwrap());
58        response
59            .pop_method_response()
60            .unwrap()
61            .unwrap_set_mailbox()
62            .unwrap()
63            .created(&create_id)
64            .unwrap()
65            .take_id()
66    } else {
67        unreachable!()
68    };
69
70    // Enable push notifications over WS
71    client
72        .enable_push_ws(None::<Vec<_>>, None::<&str>)
73        .await
74        .unwrap();
75
76    // Make changes over standard HTTP and expect a push notification via WS
77    client
78        .mailbox_update_sort_order(&mailbox_id, 1)
79        .await
80        .unwrap();
81    if let Some(WebSocketMessage::StateChange(changes)) = stream_rx.recv().await {
82        println!("Received changes: {:?}", changes);
83    } else {
84        unreachable!()
85    }
86}

Source

pub fn created_ids(&self) -> Option<impl Iterator<Item = (&String, &String)>>

Source

pub fn session_state(&self) -> &str

Source

pub fn request_id(&self) -> Option<&str>

Examples found in repository ?

examples/websocket.rs (line 57)

25async fn websocket() {
26    // Connect to the JMAP server using Basic authentication
27    let client = Client::new()
28        .credentials(("john@example.org", "secret"))
29        .connect("https://jmap.example.org")
30        .await
31        .unwrap();
32
33    // Connect to the WebSocket endpoint
34    let mut ws_stream = client.connect_ws().await.unwrap();
35
36    // Read WS messages on a separate thread
37    let (stream_tx, mut stream_rx) = mpsc::channel::<WebSocketMessage>(100);
38    tokio::spawn(async move {
39        while let Some(change) = ws_stream.next().await {
40            stream_tx.send(change.unwrap()).await.unwrap();
41        }
42    });
43
44    // Create a mailbox over WS
45    let mut request = client.build();
46    let create_id = request
47        .set_mailbox()
48        .create()
49        .name("WebSocket Test")
50        .create_id()
51        .unwrap();
52    let request_id = request.send_ws().await.unwrap();
53
54    // Read response from WS stream
55    let mailbox_id = if let Some(WebSocketMessage::Response(mut response)) = stream_rx.recv().await
56    {
57        assert_eq!(request_id, response.request_id().unwrap());
58        response
59            .pop_method_response()
60            .unwrap()
61            .unwrap_set_mailbox()
62            .unwrap()
63            .created(&create_id)
64            .unwrap()
65            .take_id()
66    } else {
67        unreachable!()
68    };
69
70    // Enable push notifications over WS
71    client
72        .enable_push_ws(None::<Vec<_>>, None::<&str>)
73        .await
74        .unwrap();
75
76    // Make changes over standard HTTP and expect a push notification via WS
77    client
78        .mailbox_update_sort_order(&mailbox_id, 1)
79        .await
80        .unwrap();
81    if let Some(WebSocketMessage::StateChange(changes)) = stream_rx.recv().await {
82        println!("Received changes: {:?}", changes);
83    } else {
84        unreachable!()
85    }
86}