Struct GetRequest

pub struct GetRequest<O: GetObject> { /* private fields */ }

Implementations

impl<O: GetObject> GetRequest<O>

pub fn new(params: RequestParams) -> Self

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

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

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

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

Examples found in repository

examples/result_reference.rs (line 58)

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 properties( &mut self, properties: impl IntoIterator<Item = O::Property>, ) -> &mut Self

Examples found in repository

examples/result_reference.rs (lines 58-64)

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 properties_ref(&mut self, reference: ResultReference) -> &mut Self

Examples found in repository

examples/result_reference.rs (line 85)

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::GetArguments

pub fn result_reference(&self, property: O::Property) -> ResultReference

Trait Implementations

impl<O: Clone + GetObject> Clone for GetRequest<O>

where O::Property: Clone, O::GetArguments: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Debug + GetObject> Debug for GetRequest<O>

where O::Property: Debug, O::GetArguments: Debug,

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

Formats the value using the given formatter.

impl<O: GetObject> Serialize for GetRequest<O>

where O::GetArguments: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.