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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
use axum::extract::{Multipart, Path};
use axum::http::StatusCode;
use axum::Json;
use rand::distributions::Alphanumeric;
use rand::Rng;
use serde::{Deserialize, Serialize};
use serde_json::{json, value::Value as JsonValue};
use std::io::Cursor;
use std::path::PathBuf;
use crate::db::bots::{self, CodeBundle};
use crate::db::users::User;
use crate::{DatabaseConnection, BOTS_DIR};
use bots::Bot;
#[derive(Serialize, Deserialize, Debug)]
pub struct BotParams {
name: String,
}
pub async fn create_bot(
conn: DatabaseConnection,
user: User,
params: Json<BotParams>,
) -> (StatusCode, Json<Bot>) {
let bot_params = bots::NewBot {
owner_id: user.id,
name: ¶ms.name,
};
let bot = bots::create_bot(&bot_params, &conn).unwrap();
(StatusCode::CREATED, Json(bot))
}
// TODO: handle errors
pub async fn get_bot(
conn: DatabaseConnection,
Path(bot_id): Path<i32>,
) -> Result<Json<JsonValue>, StatusCode> {
let bot = bots::find_bot(bot_id, &conn).map_err(|_| StatusCode::NOT_FOUND)?;
let bundles = bots::find_bot_code_bundles(bot.id, &conn)
.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
Ok(Json(json!({
"bot": bot,
"bundles": bundles,
})))
}
pub async fn get_my_bots(
conn: DatabaseConnection,
user: User,
) -> Result<Json<Vec<Bot>>, StatusCode> {
bots::find_bots_by_owner(user.id, &conn)
.map(Json)
.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}
pub async fn list_bots(conn: DatabaseConnection) -> Result<Json<Vec<Bot>>, StatusCode> {
bots::find_all_bots(&conn)
.map(Json)
.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)
}
// TODO: currently this only implements the happy flow
pub async fn upload_code_multipart(
conn: DatabaseConnection,
user: User,
Path(bot_id): Path<i32>,
mut multipart: Multipart,
) -> Result<Json<CodeBundle>, StatusCode> {
let bots_dir = PathBuf::from(BOTS_DIR);
let bot = bots::find_bot(bot_id, &conn).map_err(|_| StatusCode::NOT_FOUND)?;
if user.id != bot.owner_id {
return Err(StatusCode::FORBIDDEN);
}
let data = multipart
.next_field()
.await
.map_err(|_| StatusCode::BAD_REQUEST)?
.ok_or(StatusCode::BAD_REQUEST)?
.bytes()
.await
.map_err(|_| StatusCode::BAD_REQUEST)?;
// TODO: this random path might be a bit redundant
let folder_name: String = rand::thread_rng()
.sample_iter(&Alphanumeric)
.take(16)
.map(char::from)
.collect();
zip::ZipArchive::new(Cursor::new(data))
.map_err(|_| StatusCode::BAD_REQUEST)?
.extract(bots_dir.join(&folder_name))
.map_err(|_| StatusCode::BAD_REQUEST)?;
let bundle = bots::NewCodeBundle {
bot_id: bot.id,
path: &folder_name,
};
let code_bundle =
bots::create_code_bundle(&bundle, &conn).expect("Failed to create code bundle");
Ok(Json(code_bundle))
}
|
