hvz/endpoints/
admin.rs

1use actix_web::{HttpRequest, HttpResponse, Responder, get, post, web};
2use serde::{Deserialize, Serialize};
3
4use crate::{
5    player::{Player, PlayerState},
6    token::Token,
7};
8
9/// Struct representing a request to recover a player's password
10#[derive(Debug, Serialize, Deserialize)]
11pub struct RecoverPassword {
12    pub username: String,
13    pub password: String,
14}
15
16/// Struct used to set the checkpoint
17#[derive(Debug, Serialize, Deserialize)]
18pub struct SetCheckpoint {
19    pub x: String,
20    pub y: String,
21}
22
23/// **POST /admin/recover_password/{url_id}** - Recover a player's password
24#[post("/admin/recover_password/{url_id}")]
25pub async fn recover_password(
26    url_id: web::Path<String>,
27    req: HttpRequest,
28    form: web::Json<RecoverPassword>,
29) -> impl Responder {
30    if let Err(e) = Token::check_token(&req, &url_id).await {
31        return HttpResponse::Forbidden().body(e);
32    }
33
34    let admin = match Player::get_player(url_id.into_inner()).await {
35        Ok(Some(player)) => {
36            if let Err(err) = player.ensure_admin().await {
37                return HttpResponse::Unauthorized().body(err);
38            };
39            player
40        }
41        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
42        Err(err) => return HttpResponse::InternalServerError().body(err),
43    };
44
45    let RecoverPassword { username, password } = form.into_inner();
46    let result = admin.recover_password(username, password).await;
47
48    match result {
49        Ok(()) => HttpResponse::Ok().body("Password recovered"),
50        Err(err) => HttpResponse::InternalServerError().body(err),
51    }
52}
53
54/// **GET /admin/player_count/{url_id}** - Get the count of players
55#[get("/admin/player_count/{url_id}")]
56pub async fn player_count(url_id: web::Path<String>, req: HttpRequest) -> impl Responder {
57    if let Err(e) = Token::check_token(&req, &url_id).await {
58        return HttpResponse::Forbidden().body(e);
59    }
60
61    let admin = match Player::get_player(url_id.into_inner()).await {
62        Ok(Some(player)) => {
63            if let Err(err) = player.ensure_admin().await {
64                return HttpResponse::Unauthorized().body(err);
65            };
66            player
67        }
68        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
69        Err(err) => return HttpResponse::InternalServerError().body(err),
70    };
71
72    let result = admin.count_player().await;
73
74    match result {
75        Ok(count) => HttpResponse::Ok().body(count),
76        Err(err) => HttpResponse::InternalServerError().body(err),
77    }
78}
79
80/// **GET /admin/get_players/{url_id}** - Get all players
81#[get("/admin/get_players/{url_id}")]
82pub async fn get_all_players(url_id: web::Path<String>, req: HttpRequest) -> impl Responder {
83    if let Err(e) = Token::check_token(&req, &url_id).await {
84        return HttpResponse::Forbidden().body(e);
85    }
86
87    let admin = match Player::get_player(url_id.into_inner()).await {
88        Ok(Some(player)) => {
89            if let Err(err) = player.ensure_admin().await {
90                return HttpResponse::Unauthorized().body(err);
91            };
92            player
93        }
94        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
95        Err(err) => return HttpResponse::InternalServerError().body(err),
96    };
97
98    let result = admin.admin_get_players().await;
99
100    match result {
101        Ok(players) => HttpResponse::Ok().json(players),
102        Err(err) => HttpResponse::InternalServerError().body(err),
103    }
104}
105
106/// **POST /admin/set_checkpoint/{url_id}** - Set the checkpoint
107#[post("/admin/set_checkpoint/{url_id}")]
108pub async fn set_checkpoint(
109    url_id: web::Path<String>,
110    req: HttpRequest,
111    form: web::Json<SetCheckpoint>,
112) -> impl Responder {
113    if let Err(e) = Token::check_token(&req, &url_id).await {
114        return HttpResponse::Forbidden().body(e);
115    }
116
117    let admin = match Player::get_player(url_id.into_inner()).await {
118        Ok(Some(player)) => {
119            if let Err(err) = player.ensure_admin().await {
120                return HttpResponse::Unauthorized().body(err);
121            };
122            player
123        }
124        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
125        Err(err) => return HttpResponse::InternalServerError().body(err),
126    };
127
128    let coordinates = form.into_inner();
129    let result = admin.set_checkpoint(coordinates.x, coordinates.y).await;
130
131    match result {
132        Ok(_) => HttpResponse::Ok().body("Checkpoint set successfully"),
133        Err(err) => HttpResponse::InternalServerError().body(err),
134    }
135}
136
137/// **POST /admin/player_at_checkpoint/{url_id}** - Register a player that has gone through the checkpoint
138#[post("/admin/player_at_checkpoint/{url_id}")]
139pub async fn player_at_checkpoint(
140    url_id: web::Path<String>,
141    req: HttpRequest,
142    form: web::Json<String>,
143) -> impl Responder {
144    if let Err(e) = Token::check_token(&req, &url_id).await {
145        return HttpResponse::Forbidden().body(e);
146    }
147
148    let admin = match Player::get_player(url_id.into_inner()).await {
149        Ok(Some(player)) => {
150            if let Err(err) = player.ensure_admin().await {
151                return HttpResponse::Unauthorized().body(err);
152            };
153            player
154        }
155        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
156        Err(err) => return HttpResponse::InternalServerError().body(err),
157    };
158
159    let id = form.into_inner();
160    let result = admin.player_at_checkpoint(id).await;
161
162    match result {
163        Ok(result) => HttpResponse::Ok().body(result),
164        Err(err) => HttpResponse::InternalServerError().body(err),
165    }
166}
167
168/// **POST /admin/kill_all_not_at_checkpoint/{url_id}** - Kill all players that didn't go through the checkpoint
169#[post("/admin/kill_all_not_at_checkpoint/{url_id}")]
170pub async fn kill_all_not_at_checkpoint(
171    url_id: web::Path<String>,
172    req: HttpRequest,
173) -> impl Responder {
174    if let Err(e) = Token::check_token(&req, &url_id).await {
175        return HttpResponse::Forbidden().body(e);
176    }
177
178    let admin = match Player::get_player(url_id.into_inner()).await {
179        Ok(Some(player)) => {
180            if let Err(err) = player.ensure_admin().await {
181                return HttpResponse::Unauthorized().body(err);
182            };
183            player
184        }
185        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
186        Err(err) => return HttpResponse::InternalServerError().body(err),
187    };
188
189    let result = admin.kill_all_not_at_checkpoint().await;
190
191    match result {
192        Ok(_) => HttpResponse::Ok().body("All players killed"),
193        Err(err) => HttpResponse::InternalServerError().body(err),
194    }
195}
196
197/// **POST /admin/inject_sql/{url_id}** - Inject SQL query
198#[post("/admin/inject_sql/{url_id}")]
199pub async fn inject_sql(
200    url_id: web::Path<String>,
201    req: HttpRequest,
202    form: web::Json<String>,
203) -> impl Responder {
204    if let Err(e) = Token::check_token(&req, &url_id).await {
205        return HttpResponse::Forbidden().body(e);
206    }
207
208    let admin = match Player::get_player(url_id.into_inner()).await {
209        Ok(Some(player)) => {
210            if let Err(err) = player.ensure_admin().await {
211                return HttpResponse::Unauthorized().body(err);
212            };
213            player
214        }
215        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
216        Err(err) => return HttpResponse::InternalServerError().body(err),
217    };
218
219    let sql_query = form.into_inner();
220    let result = admin.inject_sql(sql_query).await;
221
222    match result {
223        Ok(_) => HttpResponse::Ok().body("SQL injected successfully"),
224        Err(err) => HttpResponse::InternalServerError().body(err),
225    }
226}
227
228/// **GET /admin/get_logs/{url_id}** - Get logs
229#[get("/admin/get_logs/{url_id}")]
230pub async fn get_logs(url_id: web::Path<String>, req: HttpRequest) -> impl Responder {
231    if let Err(e) = Token::check_token(&req, &url_id).await {
232        return HttpResponse::Forbidden().body(e);
233    }
234
235    let admin = match Player::get_player(url_id.into_inner()).await {
236        Ok(Some(player)) => {
237            if let Err(err) = player.ensure_admin().await {
238                return HttpResponse::Unauthorized().body(err);
239            };
240            player
241        }
242        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
243        Err(err) => return HttpResponse::InternalServerError().body(err),
244    };
245
246    let result = admin.get_logs().await;
247
248    match result {
249        Ok(logs) => HttpResponse::Ok().body(logs),
250        Err(err) => HttpResponse::InternalServerError().body(err),
251    }
252}
253
254/// **POST /admin/feed/{url_id}** - Feed the first n players
255#[post("/admin/feed/{url_id}")]
256pub async fn feed_players(
257    url_id: web::Path<String>,
258    req: HttpRequest,
259    form: web::Json<i32>,
260) -> impl Responder {
261    if let Err(e) = Token::check_token(&req, &url_id).await {
262        return HttpResponse::Forbidden().body(e);
263    }
264
265    let admin = match Player::get_player(url_id.into_inner()).await {
266        Ok(Some(player)) => {
267            if let Err(err) = player.ensure_admin().await {
268                return HttpResponse::Unauthorized().body(err);
269            };
270            player
271        }
272        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
273        Err(err) => return HttpResponse::InternalServerError().body(err),
274    };
275
276    let result = admin.feed_players(form.into_inner()).await;
277
278    match result {
279        Ok(_) => HttpResponse::Ok().body("Players fed successfully"),
280        Err(err) => HttpResponse::InternalServerError().body(err),
281    }
282}
283
284/// **POST /admin/feed_player/{url_id}** - Feed player
285#[post("/admin/feed_player/{url_id}")]
286pub async fn feed_player(
287    url_id: web::Path<String>,
288    req: HttpRequest,
289    form: web::Form<String>,
290) -> impl Responder {
291    if let Err(e) = Token::check_token(&req, &url_id).await {
292        return HttpResponse::Forbidden().body(e);
293    }
294
295    let admin = match Player::get_player(url_id.into_inner()).await {
296        Ok(Some(player)) => {
297            if let Err(err) = player.ensure_admin().await {
298                return HttpResponse::Unauthorized().body(err);
299            };
300            player
301        }
302        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
303        Err(err) => return HttpResponse::InternalServerError().body(err),
304    };
305
306    let result = admin.admin_feed(form.into_inner()).await;
307
308    match result {
309        Ok(_) => HttpResponse::Ok().body("Player fed successfully"),
310        Err(err) => HttpResponse::InternalServerError().body(err),
311    }
312}
313
314/// **POST /admin/zombies_add_day/{url_id}** - Feeds all zombies for a day
315#[post("/admin/zombies_add_day/{url_id}")]
316pub async fn zombies_add_day(url_id: web::Path<String>, req: HttpRequest) -> impl Responder {
317    if let Err(e) = Token::check_token(&req, &url_id).await {
318        return HttpResponse::Forbidden().body(e);
319    }
320
321    let admin = match Player::get_player(url_id.into_inner()).await {
322        Ok(Some(player)) => {
323            if let Err(err) = player.ensure_admin().await {
324                return HttpResponse::Unauthorized().body(err);
325            };
326            player
327        }
328        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
329        Err(err) => return HttpResponse::InternalServerError().body(err),
330    };
331
332    let result = admin.feed_zombies_day().await;
333
334    match result {
335        Ok(_) => HttpResponse::Ok().body("Zombies fed successfully"),
336        Err(err) => HttpResponse::InternalServerError().body(err),
337    }
338}
339
340/// **POST /admin/corpsify/{url_id}** - Kill a player
341#[post("/admin/corpsify/{url_id}")]
342pub async fn corpsify(
343    url_id: web::Path<String>,
344    req: HttpRequest,
345    form: web::Json<String>,
346) -> impl Responder {
347    if let Err(e) = Token::check_token(&req, &url_id).await {
348        return HttpResponse::Forbidden().body(e);
349    }
350
351    let admin = match Player::get_player(url_id.into_inner()).await {
352        Ok(Some(player)) => {
353            if let Err(err) = player.ensure_admin().await {
354                return HttpResponse::Unauthorized().body(err);
355            };
356            player
357        }
358        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
359        Err(err) => return HttpResponse::InternalServerError().body(err),
360    };
361
362    let result = admin
363        .transform(form.into_inner(), PlayerState::Corpse)
364        .await;
365
366    match result {
367        Ok(_) => HttpResponse::Ok().body("Player killed successfully"),
368        Err(err) => HttpResponse::InternalServerError().body(err),
369    }
370}
371
372/// **POST /admin/cure/{url_id}** - Cure a zombie
373#[post("/admin/cure/{url_id}")]
374pub async fn cure_zombie(
375    url_id: web::Path<String>,
376    req: HttpRequest,
377    form: web::Json<String>,
378) -> impl Responder {
379    if let Err(e) = Token::check_token(&req, &url_id).await {
380        return HttpResponse::Forbidden().body(e);
381    }
382
383    let admin = match Player::get_player(url_id.into_inner()).await {
384        Ok(Some(player)) => {
385            if let Err(err) = player.ensure_admin().await {
386                return HttpResponse::Unauthorized().body(err);
387            };
388            player
389        }
390        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
391        Err(err) => return HttpResponse::InternalServerError().body(err),
392    };
393
394    let result = admin.cure(form.into_inner()).await;
395
396    match result {
397        Ok(_) => HttpResponse::Ok().body("Player cured successfully"),
398        Err(err) => HttpResponse::InternalServerError().body(err),
399    }
400}
401
402/// **POST /admin/revive_h/{url_id}** - Revive a corpse to human
403#[post("/admin/revive_h/{url_id}")]
404pub async fn revive_human(
405    url_id: web::Path<String>,
406    req: HttpRequest,
407    form: web::Json<String>,
408) -> impl Responder {
409    if let Err(e) = Token::check_token(&req, &url_id).await {
410        return HttpResponse::Forbidden().body(e);
411    }
412
413    let admin = match Player::get_player(url_id.into_inner()).await {
414        Ok(Some(player)) => {
415            if let Err(err) = player.ensure_admin().await {
416                return HttpResponse::Unauthorized().body(err);
417            };
418            player
419        }
420        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
421        Err(err) => return HttpResponse::InternalServerError().body(err),
422    };
423
424    let result = admin.transform(form.into_inner(), PlayerState::Human).await;
425
426    match result {
427        Ok(_) => HttpResponse::Ok().body("Player revived successfully"),
428        Err(err) => HttpResponse::InternalServerError().body(err),
429    }
430}
431
432/// **POST /admin/revive_z/{url_id}** - Revive a corpse to zombie
433#[post("/admin/revive_z/{url_id}")]
434pub async fn revive_zombie(
435    url_id: web::Path<String>,
436    req: HttpRequest,
437    form: web::Json<String>,
438) -> impl Responder {
439    if let Err(e) = Token::check_token(&req, &url_id).await {
440        return HttpResponse::Forbidden().body(e);
441    }
442
443    let admin = match Player::get_player(url_id.into_inner()).await {
444        Ok(Some(player)) => {
445            if let Err(err) = player.ensure_admin().await {
446                return HttpResponse::Unauthorized().body(err);
447            };
448            player
449        }
450        Ok(None) => return HttpResponse::NotFound().body("Player not found"),
451        Err(err) => return HttpResponse::InternalServerError().body(err),
452    };
453
454    let result = admin
455        .transform(form.into_inner(), PlayerState::Zombie)
456        .await;
457
458    match result {
459        Ok(_) => HttpResponse::Ok().body("Player revived successfully"),
460        Err(err) => HttpResponse::InternalServerError().body(err),
461    }
462}
hvz/endpoints/admin.rs

hvz/endpoints/
admin.rs
