Struct SetRequest 

pub struct SetRequest<O: SetObject> { /* private fields */ }

Implementations

impl<O: SetObject> SetRequest<O>

pub fn new(params: RequestParams) -> Self

pub fn account_id(&mut self, account_id: impl Into<String>) -> &mut Self

pub fn if_in_state(&mut self, if_in_state: impl Into<String>) -> &mut Self

pub fn create(&mut self) -> &mut O

Examples found in repository

examples/websocket.rs (line 48)

async fn websocket() {
    // Connect to the JMAP server using Basic authentication
    let client = Client::new()
        .credentials(("john@example.org", "secret"))
        .connect("https://jmap.example.org")
        .await
        .unwrap();

    // Connect to the WebSocket endpoint
    let mut ws_stream = client.connect_ws().await.unwrap();

    // Read WS messages on a separate thread
    let (stream_tx, mut stream_rx) = mpsc::channel::<WebSocketMessage>(100);
    tokio::spawn(async move {
        while let Some(change) = ws_stream.next().await {
            stream_tx.send(change.unwrap()).await.unwrap();
        }
    });

    // Create a mailbox over WS
    let mut request = client.build();
    let create_id = request
        .set_mailbox()
        .create()
        .name("WebSocket Test")
        .create_id()
        .unwrap();
    let request_id = request.send_ws().await.unwrap();

    // Read response from WS stream
    let mailbox_id = if let Some(WebSocketMessage::Response(mut response)) = stream_rx.recv().await
    {
        assert_eq!(request_id, response.request_id().unwrap());
        response
            .pop_method_response()
            .unwrap()
            .unwrap_set_mailbox()
            .unwrap()
            .created(&create_id)
            .unwrap()
            .take_id()
    } else {
        unreachable!()
    };

    // Enable push notifications over WS
    client
        .enable_push_ws(None::<Vec<_>>, None::<&str>)
        .await
        .unwrap();

    // Make changes over standard HTTP and expect a push notification via WS
    client
        .mailbox_update_sort_order(&mailbox_id, 1)
        .await
        .unwrap();
    if let Some(WebSocketMessage::StateChange(changes)) = stream_rx.recv().await {
        println!("Received changes: {:?}", changes);
    } else {
        unreachable!()
    }
}

pub fn create_with_id(&mut self, create_id: impl Into<String>) -> &mut O

pub fn create_item(&mut self, item: O) -> String

pub fn update(&mut self, id: impl Into<String>) -> &mut O

pub fn update_item(&mut self, id: impl Into<String>, item: O)

pub fn destroy<U, V>(&mut self, ids: U) -> &mut Self

where U: IntoIterator<Item = V>, V: Into<String>,

pub fn destroy_ref(&mut self, reference: ResultReference) -> &mut Self

Examples found in repository

examples/result_reference.rs (line 37)

async fn result_reference() {
    // Connect to the JMAP server using Basic authentication
    let client = Client::new()
        .credentials(("john@example.org", "secret"))
        .connect("https://jmap.example.org")
        .await
        .unwrap();

    // Delete e-mails matching a filter
    let mut request = client.build();
    let result_ref = request
        .query_email()
        .filter(query::Filter::and([
            email::query::Filter::has_keyword("$draft"),
            email::query::Filter::from("bill"),
        ]))
        .result_reference();
    request.set_email().destroy_ref(result_ref);
    let _destroyed_ids = request
        .send()
        .await
        .unwrap()
        .unwrap_method_responses()
        .pop()
        .unwrap()
        .unwrap_set_email()
        .unwrap()
        .take_destroyed_ids();

    // Fetch mailboxes matching a filter
    let mut request = client.build();
    let query_result = request
        .query_mailbox()
        .filter(query::Filter::and([
            mailbox::query::Filter::has_any_role(false),
            mailbox::query::Filter::is_subscribed(true),
        ]))
        .result_reference();
    request.get_mailbox().ids_ref(query_result).properties([
        mailbox::Property::Id,
        mailbox::Property::Name,
        mailbox::Property::ParentId,
        mailbox::Property::TotalEmails,
        mailbox::Property::UnreadEmails,
    ]);
    let _mailboxes = request
        .send()
        .await
        .unwrap()
        .unwrap_method_responses()
        .pop()
        .unwrap()
        .unwrap_get_mailbox()
        .unwrap()
        .take_list();

    // Fetch only the updated properties of all mailboxes that changed
    // since a state.
    let mut request = client.build();
    let changes_request = request.changes_mailbox("n").max_changes(0);
    let properties_ref = changes_request.updated_properties_reference();
    let updated_ref = changes_request.updated_reference();
    request
        .get_mailbox()
        .ids_ref(updated_ref)
        .properties_ref(properties_ref);
    for mailbox in request
        .send()
        .await
        .unwrap()
        .unwrap_method_responses()
        .pop()
        .unwrap()
        .unwrap_get_mailbox()
        .unwrap()
        .take_list()
    {
        println!("Changed mailbox: {:#?}", mailbox);
    }
}

pub fn arguments(&mut self) -> &mut O::SetArguments

Trait Implementations

impl<O: Clone + SetObject> Clone for SetRequest<O>

where O::SetArguments: Clone,

fn clone(&self) -> SetRequest<O>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<O: Debug + SetObject> Debug for SetRequest<O>

where O::SetArguments: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<O> Serialize for SetRequest<O>

where O: Serialize + SetObject, O::SetArguments: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.