Useage
````rust
use std::pin::Pin;
use athene::{Request, Response, Result, StatusCode, Error, Middleware, Next};
pub async fn hello(req: Request) -> Result{
let name: String = req.param("name").unwrap();
let mut res = Response::default();
res.text(name)?;
Ok(res)
}
pub async fn world(_req: Request) -> Result{
let mut res = Response::default();
res.text("world")?;
Ok(res)
}
pub async fn welcome(req: Request) -> Result{
let user = req.query::().unwrap();
let mut res = Response::default();
res.json(&user)?;
Ok(res)
}
pub async fn redirect(req: Request) -> Result{
println!("redirect handler");
Response::redirect(StatusCode::MOVEDPERMANENTLY,"/api/rust")
}
pub async fn code(_req: Request) -> Result{
let mut res = Response::default();
res.text("code handler")?;
Ok(res)
}
pub async fn rustlang(req: Request) -> Result{
let mut res = Response::default();
res.text("welcome to rust_lang world")?;
Ok(res)
}
pub async fn permanent(req: Request) -> Result{
Response::redirect(StatusCode::PERMANENTREDIRECT,"/api/code")
}
pub async fn temporary(req: Request) -> Result{
Response::redirect(StatusCode::TEMPORARYREDIRECT,"/api/world")
}
pub async fn location(_req: Request) -> Result{
Response::location("/")
}
[derive(serde::Serialize,serde::Deserialize)]
pub struct User {
name: String,
age: i32,
}
pub async fn login(req: Request) -> Result{
let mut req = req;
let user = req.parse::().await?;
let mut res = Response::default();
res.json(&user)?;
Ok(res)
}
pub async fn upload(req: Request) -> Result{
let mut req = req;
let file = req.file("file").await?;
std::fs::createdirall("temp").unwrap();
let dest = format!("temp/{}", file.name().unwrap_or("file"));
let info = if let Err(e) = std::fs::copy(file.path(), std::path::Path::new(&dest)){
format!("file not found in request: {e}")
} else {
format!("File uploaded to {dest}")
};
let mut res = Response::default();
res.text(info)?;
Ok(res)
}
pub async fn uploads(req: Request) -> Result{
let mut req = req;
let mut res = Response::default();
let files = req.files("files").await?;
std::fs::createdirall("temp").unwrap();
let mut msgs = Vec::withcapacity(files.len());
for file in files {
let dest = format!("temp/{}", file.name().unwrapor("file"));
if let Err(e) = std::fs::copy(file.path(), std::path::Path::new(&dest)){
res.text(format!("file not found in request: {e}"))?;
} else {
msgs.push(dest);
}
}
res.text(format!("Files uploaded:\n\n{}", msgs.join("\n")))?;
Ok(res)
}
pub async fn authindex(: Request) -> Result {
let mut res = Response::default();
res.text("The current handler auth_index has been not authenticated ")?;
Ok(res)
}
[derive(Debug)]
pub struct Logger;
[asynctrait::asynctrait]
impl Middleware for Logger {
async fn handle(self: Pin<&Self>, request: Request,next: Next<'_>) -> Result {
// let mut res = Response::default();
// res.text("logger middleware is used")?;
// Ok(res)
let res = next.next(request).await?;
Ok(res)
}
}
[tokio::main]
pub async fn main() -> Result<(),Error>{
let mut router = athene::new();
router.get("/", redirect);
router.get("/permanent", permanent);
router.get("/temporary", temporary);
router.get("/base",welcome);
router.post("/upload", upload);
router.post("/uploads", uploads);
router.get("/location", location);
router.group("/api", |base|{
base.get("/hello/{name}", hello);
base.get("/world",world);
base.get("/code",code);
base.get("/rust",rust_lang);
base.group("/user",|user|{
user.post("/",login);
});
});
router.middleware(Logger).group("/auth", |base|{
base.get("/index", auth_index);
});
router.listen("127.0.0.1:8081").await
}
````