Useage

````rust use askama::Template; use serde::{Serialize,Deserialize}; use athene::{Error, Middleware, Next, Request, Response, Result, StatusCode}; use tera::{Tera,Context}; use std::pin::Pin;

[derive(Serialize,Deserialize)]

pub struct User { name: String, age: i32, }

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("/") }

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(serde::Serialize, Hash, Eq, PartialEq, Clone, Template)]

[template(path = "favorite.html")]

pub struct Favorite<'a> { title: &'a str, time: i32, }

[allow(dead_code)]

const LOVE: Favorite = Favorite { title: "rust_lang", time: 1314, };

pub async fn askamatemplate(: Request) -> Result { let mut res = Response::default(); let love = LOVE.render()?; res.html(love)?; Ok(res) }

[derive(Serialize)]

struct Awesome<'a> { url: &'a str, name: &'a str, }

pub async fn teratemplate(: Request) -> Result { let tera = Tera::new("templates/*")?; let mut ctx = Context::new(); ctx.insert("title", "Welcome to rust-lang world!"); ctx.insert( "product", &vec![ Awesome { url: "https://github.com/rust-lang", name: "rust-lang", }, Awesome { url: "https://github.com/lapce/lapce", name: "lapce", }, ], ); let mut res = Response::default(); let love = tera.render("index.html",&ctx)?; res.html(love)?; 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.get("/askamatemplate", askamatemplate); router.get("/teratemplate", teratemplate);

router.group("/closure", |base| {
    base.get("/str", |_req| async { "closure str" });
    base.get("/string", |_| async { String::from("closure string") });
    base.get("/vec/", |_| async { [1, 3, 5, 7, 9].to_vec() });
    base.get("/status", |_| async { StatusCode::NO_CONTENT });
    base.get("/empty", |_| async {});
    base.get("/empty/bracket", |_| async { () });
    base.get("/remote_addr", |req: Request| async move {
        let addr = req.remote_addr().unwrap();
        let addr = addr.to_string();
        addr
    });
    base.get("/remote_ip", |req: Request| async move {
        let ip = req.ip().unwrap();
        let ip = ip.to_string();
        ip
    });
    base.get("/status/value", |_| async {
        (StatusCode::NOT_FOUND, "welcome to my world")
    });
});

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

} ````

templates/index.html

````html

{% for one in product -%}
• {{ one.name }}
{%- endfor %}

````

templates/favorite.html

````html

{{title}}

{{time}}

````