HTTP Request URL Parameters Syntax

| Pattern | Kind | Description | | ------------------------------- | ------------------- | ------------------------------------------------------------------------------ | | :name | Normal | Matches a path piece, excludes / | | :name? | Optional | Matches an optional path piece, excludes / | | /:name?/ /:name? | OptionalSegment | Matches an optional path segment, excludes /, prefix or suffix should be / | | + :name+ | OneOrMore | Matches a path piece, includes / | | * :name* | ZeroOrMore | Matches an optional path piece, includes / | | /*/ /* /:name*/ /:name* | ZeroOrMoreSegment | Matches zero or more path segments, prefix or suffix should be /

⚡️ Quick Start

````rust use hypers::prelude::*; use std::time::Instant;

[derive(Serialize, Deserialize)]

pub struct User { pub id: Option, pub name: Option, pub age: Option, }

[derive(Serialize, Deserialize)]

pub struct QueryParams { pub id: Option, pub name: Option, }

pub async fn create(mut req: Request) -> impl Responder { let user = req.parse::().await?; /* ...... */ Ok::<_, Error>((200, Json(user))) }

pub async fn update(mut req: Request) -> impl Responder { let user = req.parse::().await?; let id = req.param::<&str>("id"); println!("id = {:?}", id); /* ..... */ Ok::<_, Error>((200, Json(user))) }

// Url Query Params pub async fn query(req: Request) -> impl Responder { let queryparams = req.query::()?; /* ..... */ Ok::<_, Error>((200, Form(queryparams))) }

// Url Path Params pub async fn delete(req: Request) -> impl Responder { let id = req.param::("id")?; let name = req.param::("name")?; /* ..... */ Some((200, format!("id = {}, name = {}", id, name))) }

pub async fn multipartformdata(mut req: Request) -> impl Responder { let file = req.file("file").await?; let filename = file.name()?; let filename = filename.tostring();

let img = req.files("imgs").await?;
let imgs_name = img
    .iter()
    .map(|m| m.name().unwrap().to_string())
    .collect::<Vec<String>>()
    .join(",");

let name = req.form::<String>("name").await?;

Some((
    200,
    format!(
        "file_name = {}, imgs_name = {}, name = {}",
        file_name, imgs_name, name
    ),
))

}

pub async fn parseheader(req: Request) -> impl Responder { let host = req.header::("host")?; let useragent = req.header::("user-agent")?; let accept: String = req.header("accept")?; Some(( 200, format!( "host = {}\n useragent = {}\n accept = {}", host, useragent, accept ), )) }

// Websocket ws://127.0.0.1:7878/hello/ws http://www.jsons.cn/websocket/ pub async fn websocket(req: Request, mut ws: WebSocket) -> Result<()> { let name = req.param::("name").unwrapordefault(); while let Ok(msg) = ws.receive().await { if let Some(msg) = msg { match msg { Message::Text(text) => { let text = format!("{},{}", name, text); ws.send(Message::Text(text)).await?; } Message::Close(_) => break, _ => {} } } } Ok(()) }

// Middleware Function pub async fn stattime(req: Request, netx: Next) -> Result { let starttime = Instant::now();

let res = netx.next(req).await?;

let elapsed_time = start_time.elapsed();

println!(
    "The current request processing function takes time :{:?}",
    elapsed_time
);

println!(
    "The response after the execution of the current request processing function : {:?}",
    res
);
Ok(res)

}

// Write router like a tree fn main() -> Result<()> {

// The Root Router
let mut root = Router::new("/");

// Add Middleware  ( Middleware can be added to any routing node )
root.hook(stat_time, vec!["/user"], vec!["/hello"]);
root.get("/*", StaticDir::new("src").listing(true));
root.ws(":name/ws", websocket);
root.get("/parse_header", parse_header);

// The Sub Router
let mut user = Router::new("user");
user.post("create", create)
    .patch("update/:id", update)
    .get("query", query)
    .delete("delete/:id/:name", delete)
    .post("multipart_form_data", multipart_form_data);

// Add sub router to the root router
root.push(user);

// Registering the root router into the server
let app = hypers::new(root);

// Start Server
app.run("127.0.0.1:7878")

} `````