Rocket.rs 初探 - QueryGuard, ParamGuard 以及 RequestGuard 實際範例

use rocket::http::RawStr;
use rocket::request::{Query, FromQuery};

struct Search<'q>(&'q RawStr);

impl<'q> FromQuery<'q> for Search<'q> {
    type Error = &'q str;

    fn from_query(query: Query<'q>) -> Result<Search, Self::Error> {
        // 尋找 key 為 search 且 value 的長度 > 2 的 query
        let key_items = query.filter(|item| item.key == "search" && item.value.len() >= 2);

        // 如果找到的數量為 0 代表沒有 search 或者有 search 但是值的長度不到 2
        let count = key_items.clone().count();
        if count == 0 {
            return Err("no matching search");
        }

        // 將找到的資料包裝成 Search 並返回第 0 個
        // The `ok_or` gets us a `Result`. We will never see `Err(0)`.
        return key_items.map(|i| Search(i.value)).nth(0).ok_or("no matching search");
    }
}

#[get("/products?<search..>")]
fn search_product(search: Search) -> String {
    format!("Search: {}", search.0)
}

fn main() {
    rocket::ignite().mount("/", routes![search_product]).launch();
}

use rocket::request::FromParam;
use rocket::http::RawStr;

struct Mobile<'r> {
    value: &'r str
}

impl<'r> FromParam<'r> for Mobile<'r> {
    type Error = &'r str;

    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {

        // 如果 param 的長度小於 10 則返回錯誤
        if param.len() < 10 {
            return Err("length cannot shorter than 10.");
        }
        
        extern crate regex;
        use regex::Regex;

        // 必須全部為 digit
        let re = Regex::new(r"^\d+$").unwrap();

        // 不匹配也返回錯誤
        if !re.is_match(param) {
            return Err("param should contain digit.")
        }

        return Ok(Mobile{value: param.as_str()});
    }
}

#[get("/users/<mobile>")]
fn get_user_with_mobile(mobile: Mobile) -> String
{
    return format!("User with mobile: {}", mobile.value);
}

fn main() {
    rocket::ignite().mount("/", routes![
        get_user_with_mobile
    ]).launch();
}

use rocket::request::{self, Request, FromRequest};
use rocket::Outcome;
use rocket::http::Status;

struct ApiKey(String);

fn is_valid_key(key: &str) -> bool {
    return key == "valid_key";
}

impl<'a, 'r> FromRequest<'a, 'r> for ApiKey {
    type Error = &'r str;

    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
        let keys: Vec<_> = request.headers().get("Api-Key").collect();
        match keys.len() {
            // 沒有提供 Api-Key
            0 => Outcome::Failure((Status::BadRequest, "Api-Key no provided")),
            // 提供且 Api-Key 正確
            1 if is_valid_key(keys[0]) => Outcome::Success(ApiKey(keys[0].to_string())),
            // Api-Key 不正確
            1 => Outcome::Failure((Status::BadRequest, "Api-Key invalid")),
            // 其他狀態，代表過多個 Api-Key
            _ => Outcome::Failure((Status::BadRequest, "Too many Api-Key"))
        }
    }
}

#[get("/profile")]
fn profile(api_key: ApiKey) -> String {
    return format!("Valid User, key: {}", api_key.0);
}

fn main() {
    rocket::ignite().mount("/", routes![
        profile
    ]).launch();
}