athene 2.0.4

A simple and lightweight rust web framework based on hyper
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use athene::prelude::*;
use once_cell::sync::Lazy;
use tera::{Context as TeraContext, Tera};

static TERA: Lazy<Tera> = Lazy::new(|| Tera::new("templates/*").unwrap());

#[derive(Debug, Serialize, Clone)]
pub struct Flash {
    pub kind: String,
    pub message: String,
}

#[derive(Deserialize, Debug,Validate)]
pub struct CreateForm {
    description: String,
}

#[derive(Deserialize, Debug,Validate)]
pub struct UpdateForm {
    _method: String,
}

#[derive(Debug, Serialize, Clone,Default)]
pub struct Task {
    pub id: i32,
    pub description: String,
    pub completed: bool,
}

// http://127.0.0.1:7878/task
#[controller]
impl Task {

    // http://127.0.0.1:7878/task/index
    #[get("/index")]
    pub async fn index(&self,_req: Request) -> impl Responder {
        let tasks = [
            Task {
                id: 1,
                description: "Buy a coffee ".to_string(),
                completed: true,
            },
            Task {
                id: 2,
                description: "Shopping".to_string(),
                completed: true,
            },
            Task {
                id: 3,
                description: "Coding".to_string(),
                completed: false,
            },
        ]
        .to_vec();

        let flash = Flash {
            kind: "Dangerous".to_string(),
            message: "Danger, stay away".to_string(),
        };

        let mut ctx = TeraContext::new();
        ctx.insert("tasks", &tasks);
        ctx.insert("msg", &(flash.kind, flash.message));

        let html = TERA.render("index.html", &ctx).unwrap();
        Html(html)
    }

    #[post("/todo")]
    pub async fn create(&self,form: Form<CreateForm>) -> impl Responder {
        println!("{:?}",form.0);
        StatusCode::CREATED
    }

    #[post("/todo/{id}")]
    pub async fn update(&self,id: u16, form: Form<UpdateForm>) -> impl Responder {
        println!("id = {}",id);
        println!("{:?}",form.0);
        StatusCode::CREATED
    }
}

// http://127.0.0.1:7878/task/index
#[tokio::main]
pub async fn main() -> Result<()> {
    let app = athene::new();
    let app = app.
    router(|r|r.static_dir("/**", "templates/static").controller(Task::default()));
    app.listen("127.0.0.1:7878").await
}