Skip to content

Commit dc8eca2

Browse files
pepoviolapepoviola
authored
Merge pull request #1 from pepoviola/refactor-create-rest-entity-struct
refactor - rest entity
2 parents b6be779 + 255387e commit dc8eca2

File tree

1 file changed

+83
-60
lines changed

1 file changed

+83
-60
lines changed

‎src/main.rs‎

Lines changed: 83 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,71 @@ struct Dinos {
2121
dinos: Vec<Dino>,
2222
}
2323

24+
struct RestEntity {
25+
base_path: String,
26+
}
27+
28+
impl RestEntity {
29+
async fn create(mut req: Request<State>) -> tide::Result {
30+
let dino: Dino = req.body_json().await?;
31+
// let get a mut ref of our store ( hashMap )
32+
let mut dinos = req.state().dinos.write().await;
33+
dinos.insert(String::from(&dino.name), dino.clone());
34+
let mut res = Response::new(201);
35+
res.set_body(Body::from_json(&dino)?);
36+
Ok(res)
37+
}
38+
39+
async fn list(req: tide::Request<State>) -> tide::Result {
40+
let dinos = req.state().dinos.read().await;
41+
// get all the dinos as a vector
42+
let dinos_vec: Vec<Dino> = dinos.values().cloned().collect();
43+
let mut res = Response::new(200);
44+
res.set_body(Body::from_json(&dinos_vec)?);
45+
Ok(res)
46+
}
47+
48+
async fn get(req: tide::Request<State>) -> tide::Result {
49+
let mut dinos = req.state().dinos.write().await;
50+
let key: String = req.param("id")?;
51+
let res = match dinos.entry(key) {
52+
Entry::Vacant(_entry) => Response::new(404),
53+
Entry::Occupied(entry) => {
54+
let mut res = Response::new(200);
55+
res.set_body(Body::from_json(&entry.get())?);
56+
res
57+
}
58+
};
59+
Ok(res)
60+
}
61+
62+
async fn update(mut req: tide::Request<State>) -> tide::Result {
63+
let dino_update: Dino = req.body_json().await?;
64+
let mut dinos = req.state().dinos.write().await;
65+
let key: String = req.param("id")?;
66+
let res = match dinos.entry(key) {
67+
Entry::Vacant(_entry) => Response::new(404),
68+
Entry::Occupied(mut entry) => {
69+
*entry.get_mut() = dino_update;
70+
let mut res = Response::new(200);
71+
res.set_body(Body::from_json(&entry.get())?);
72+
res
73+
}
74+
};
75+
Ok(res)
76+
}
77+
78+
async fn delete(req: tide::Request<State>) -> tide::Result {
79+
let mut dinos = req.state().dinos.write().await;
80+
let key: String = req.param("id")?;
81+
let deleted = dinos.remove(&key);
82+
let res = match deleted {
83+
None => Response::new(404),
84+
Some(_) => Response::new(204),
85+
};
86+
Ok(res)
87+
}
88+
}
2489
#[async_std::main]
2590
async fn main() {
2691
tide::log::start();
@@ -30,6 +95,17 @@ async fn main() {
3095
app.listen("127.0.0.1:8080").await.unwrap();
3196
}
3297

98+
fn register_rest_entity(app: &mut Server<State>, entity: RestEntity) {
99+
app.at(&entity.base_path)
100+
.get(RestEntity::list)
101+
.post(RestEntity::create);
102+
103+
app.at(&format!("{}/:id", entity.base_path))
104+
.get(RestEntity::get)
105+
.put(RestEntity::update)
106+
.delete(RestEntity::delete);
107+
}
108+
33109
async fn server(dinos_store: Arc<RwLock<HashMap<String, Dino>>>) -> Server<State> {
34110
let state = State {
35111
dinos: dinos_store, //Default::default(),
@@ -38,76 +114,23 @@ async fn server(dinos_store: Arc<RwLock<HashMap<String, Dino>>>) -> Server<State
38114
let mut app = tide::with_state(state);
39115
app.at("/").get(|_| async { Ok("ok") });
40116

41-
app.at("/dinos")
42-
.post(|mut req: Request<State>| async move {
43-
let dino: Dino = req.body_json().await?;
44-
// let get a mut ref of our store ( hashMap )
45-
let mut dinos = req.state().dinos.write().await;
46-
dinos.insert(String::from(&dino.name), dino.clone());
47-
println!("{:?}", dinos);
48-
let mut res = Response::new(201);
49-
res.set_body(Body::from_json(&dino)?);
50-
Ok(res)
51-
})
52-
.get(|req: Request<State>| async move {
53-
let dinos = req.state().dinos.read().await;
54-
// get all the dinos as a vector
55-
let dinos_vec: Vec<Dino> = dinos.values().cloned().collect();
56-
let mut res = Response::new(200);
57-
res.set_body(Body::from_json(&dinos_vec)?);
58-
Ok(res)
59-
});
60-
app.at("/dinos/:name")
61-
.get(|req: Request<State>| async move {
62-
let mut dinos = req.state().dinos.write().await;
63-
let key: String = req.param("name")?;
64-
let res = match dinos.entry(key) {
65-
Entry::Vacant(_entry) => Response::new(404),
66-
Entry::Occupied(entry) => {
67-
let mut res = Response::new(200);
68-
res.set_body(Body::from_json(&entry.get())?);
69-
res
70-
}
71-
};
72-
Ok(res)
73-
})
74-
.put(|mut req: Request<State>| async move {
75-
let dino_update: Dino = req.body_json().await?;
76-
let mut dinos = req.state().dinos.write().await;
77-
let key: String = req.param("name")?;
78-
let res = match dinos.entry(key) {
79-
Entry::Vacant(_entry) => Response::new(404),
80-
Entry::Occupied(mut entry) => {
81-
*entry.get_mut() = dino_update;
82-
let mut res = Response::new(200);
83-
res.set_body(Body::from_json(&entry.get())?);
84-
res
85-
}
86-
};
87-
Ok(res)
88-
})
89-
.delete(|req: Request<State>| async move {
90-
let mut dinos = req.state().dinos.write().await;
91-
let key: String = req.param("name")?;
92-
let deleted = dinos.remove(&key);
93-
let res = match deleted {
94-
None => Response::new(404),
95-
Some(_) => Response::new(204),
96-
};
97-
Ok(res)
98-
});
117+
let dinos_endpoint = RestEntity {
118+
base_path: String::from("/dinos"),
119+
};
120+
121+
register_rest_entity(&mut app, dinos_endpoint);
99122

100123
app
101124
}
102125

103126
#[async_std::test]
104127
async fn index_page() -> tide::Result<()> {
105-
use tide::http::{Method, Request, Response, Url};
128+
use tide::http::{Method, Request as httpRequest, Response, Url};
106129

107130
let dinos_store = Default::default();
108131
let app = server(dinos_store).await;
109132
let url = Url::parse("https://example.com").unwrap();
110-
let req = Request::new(Method::Get, url);
133+
let req = httpRequest::new(Method::Get, url);
111134
let mut res: Response = app.respond(req).await?;
112135
assert_eq!("ok", res.body_string().await?);
113136
Ok(())

0 commit comments

Comments
 (0)