Useage

````rust use askama::Template; use route::fifth::fifth_router; 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::new(); res.text(name)?; Ok(res) }

pub async fn world(_req: Request) -> Result{ let mut res = Response::new(); res.text("world")?; Ok(res) }

pub async fn welcome(req: Request) -> Result{ let user = req.query::().unwrap(); let mut res = Response::new(); res.json(&user)?; Ok(res) }

pub async fn index(req: Request) -> Result{ println!("redirect handler"); Response::redirect(StatusCode::MOVEDPERMANENTLY, "/api/rust") }

pub async fn code(_req: Request) -> Result{ let mut res = Response::new(); res.text("code handler")?; Ok(res) }

pub async fn rustlang(req: Request) -> Result{ let mut res = Response::new(); 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::new(); res.json(&user)?; Ok(res) }

pub async fn upload(req: Request) -> Result{ let mut req = req; let info = req.upload("file","temp").await?; use athene::IntoResponse; info.response() }

pub async fn uploads(req: Request) -> Result{ let mut req = req; let info = req.uploads("files","temp").await?; use athene::IntoResponse; info.response() }

pub async fn authindex(: Request) -> Result{ let mut res = Response::new(); 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::new(); 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::new(); 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::new(); // res.text("logger middleware is used")?; // Ok(res) let res = next.next(request).await?; Ok(res) } }

pub(crate) mod route {

pub(crate) mod first {
    use crate::{permanent, index, temporary, welcome};

    pub(crate) fn first_router() -> athene::Router{
        let mut router = athene::new(); 
        router.get("/", index);   
        router.get("/permanent", permanent);
        router.get("/temporary", temporary);
        router.get("/base", welcome);
        router
    }
}

pub(crate) mod second {
    use crate::{route::first::first_router, upload, location, uploads, askama_template, tera_template};

    pub(crate) fn second_router() -> athene::Router {
        let mut router = first_router();
        router.post("/upload", upload);
        router.post("/uploads", uploads);
        router.get("/location", location);
        router.get("/askama_template", askama_template);
        router.get("/tera_template", tera_template);
        router
    }
}

pub(crate) mod third {
    use athene::{StatusCode, Request};
    use super::second::second_router;

    pub(crate) fn third_router() -> athene::Router {
        let mut router = second_router();
        router.group("/closure", |base| {
            base.get("/str", |_req| async { "closure str" });
            base.post("/string", |_| async { String::from("closure string") });
            base.put("/vec/", |_| async { [1, 3, 5, 7, 9].to_vec() });
            base.delete("/status", |_| async { StatusCode::NO_CONTENT });
            base.options("/empty", |_| async {});
            base.head("/empty/bracket", |_| async { () });
            base.put("/remote_addr", |req: Request| async move {
                let addr = req.remote_addr().unwrap();
                let addr = addr.to_string();
                addr
            });
            base.patch("/remote_ip", |req: Request| async move {
                let ip = req.ip().unwrap();
                let ip = ip.to_string();
                ip
            });
            base.post("/status/value", |_| async {
                (StatusCode::NOT_FOUND, "welcome to my world")
            });
        });
        router
    }
}

pub(crate) mod fifth {
    use crate::{hello, world, rust_lang, code, login, Logger, auth_index};
    use super::third::third_router;

    pub(crate) fn fifth_router() -> athene::Router {
        let mut router = third_router();
        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
    }
}

}

[tokio::main]

pub async fn main() -> Result<(), Error> { let router = fifth_router(); router.listen("127.0.0.1:8081").await } ````

templates/index.html

````html {{title}}

````

templates/favorite.html

````html

Rust is one of my favorite programming languages

{{title}}

{{time}}

````