Struct QueryBuilder 

pub struct QueryBuilder { /* private fields */ }

Utility builder for building query::Query.

Implementations

impl QueryBuilder

An implementation for QueryBuilder. There are two function types:

1. functions that can accept a single argument.
2. functions that can accept a Vec type argument.

The former ones simply add the accepted value to this builder, but the latter ones always replace the value in placed in this builder by the accepted one.

pub fn begin() -> Self

Initializes QueryBuilder.

Examples found in repository

examples/get_single_event.rs (line 6)

async fn main() {
    // fetch https://rust.connpass.com/event/228732/
    let query = QueryBuilder::begin().event_id(228732).build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

examples/get_events_with_various_queries.rs (line 8)

async fn main() {
    let query = QueryBuilder::begin()
        // You can build query parameters by functions that accept a single argument,
        .keyword_or("Python")
        .keyword_or("機械学習")
        // or can do by functions that accept a `Vec` argument.
        .yms(vec![202110, 202111])
        .order(OrderOption::Newer)
        .count(15)
        .build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

pub fn event_ids(self, ids: Vec<u32>) -> Self

pub fn event_id(self, id: u32) -> Self

Examples found in repository

examples/get_single_event.rs (line 6)

async fn main() {
    // fetch https://rust.connpass.com/event/228732/
    let query = QueryBuilder::begin().event_id(228732).build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

pub fn keywords(self, keywords: Vec<String>) -> Self

pub fn keyword(self, keyword: impl Into<String>) -> Self

pub fn keywords_or(self, keywords: Vec<String>) -> Self

pub fn keyword_or(self, keyword: impl Into<String>) -> Self

Examples found in repository

examples/get_events_with_various_queries.rs (line 10)

async fn main() {
    let query = QueryBuilder::begin()
        // You can build query parameters by functions that accept a single argument,
        .keyword_or("Python")
        .keyword_or("機械学習")
        // or can do by functions that accept a `Vec` argument.
        .yms(vec![202110, 202111])
        .order(OrderOption::Newer)
        .count(15)
        .build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

pub fn yms(self, ym: Vec<u32>) -> Self

Examples found in repository

examples/get_events_with_various_queries.rs (line 13)

async fn main() {
    let query = QueryBuilder::begin()
        // You can build query parameters by functions that accept a single argument,
        .keyword_or("Python")
        .keyword_or("機械学習")
        // or can do by functions that accept a `Vec` argument.
        .yms(vec![202110, 202111])
        .order(OrderOption::Newer)
        .count(15)
        .build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

pub fn ym(self, ym: u32) -> Self

pub fn ymds(self, ymd: Vec<u32>) -> Self

pub fn ymd(self, ymd: u32) -> Self

pub fn nicknames(self, nickname: Vec<String>) -> Self

pub fn nickname(self, nickname: impl Into<String>) -> Self

pub fn owner_nicknames(self, owner_nickname: Vec<String>) -> Self

pub fn owner_nickname(self, owner_nickname: impl Into<String>) -> Self

pub fn series_ids(self, series_ids: Vec<u32>) -> Self

pub fn series_id(self, series_id: u32) -> Self

pub fn start(self, start: u32) -> Self

pub fn order(self, order: OrderOption) -> Self

Examples found in repository

examples/get_events_with_various_queries.rs (line 14)

async fn main() {
    let query = QueryBuilder::begin()
        // You can build query parameters by functions that accept a single argument,
        .keyword_or("Python")
        .keyword_or("機械学習")
        // or can do by functions that accept a `Vec` argument.
        .yms(vec![202110, 202111])
        .order(OrderOption::Newer)
        .count(15)
        .build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

pub fn count(self, count: u8) -> Self

Examples found in repository

examples/get_events_with_various_queries.rs (line 15)

async fn main() {
    let query = QueryBuilder::begin()
        // You can build query parameters by functions that accept a single argument,
        .keyword_or("Python")
        .keyword_or("機械学習")
        // or can do by functions that accept a `Vec` argument.
        .yms(vec![202110, 202111])
        .order(OrderOption::Newer)
        .count(15)
        .build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

pub fn format(self, format: impl Into<String>) -> Self

pub fn build(self) -> Result<Query, ConnpassCliError>

Converts from QueryBuilder to Query with some validation checks. The following checks run in this function:

1. validate the count value in range of 0 to 100.
2. validate if the format value is just “json”.

These validation specifications are described in connpass’s documentation. Please have a look at https://connpass.com/about/api/.

Examples found in repository

examples/get_single_event.rs (line 6)

async fn main() {
    // fetch https://rust.connpass.com/event/228732/
    let query = QueryBuilder::begin().event_id(228732).build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

examples/get_events_with_various_queries.rs (line 16)

async fn main() {
    let query = QueryBuilder::begin()
        // You can build query parameters by functions that accept a single argument,
        .keyword_or("Python")
        .keyword_or("機械学習")
        // or can do by functions that accept a `Vec` argument.
        .yms(vec![202110, 202111])
        .order(OrderOption::Newer)
        .count(15)
        .build();
    if let Ok(query) = query {
        let client = ConnpassClient::new();
        let res = client.send_request(query).await;
        match res {
            Ok(r) => println!("{:?}", r),
            Err(err) => eprintln!("{:?}", err),
        }
    }
}

Trait Implementations

impl Default for QueryBuilder

fn default() -> Self

Returns the “default value” for a type.