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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
use crate::config::PAGE_LIMIT;
use crate::db::get_client;
use crate::errors::AppError;
use serde_json::json;
use sqlx::types::JsonValue;
use chrono::{Local, NaiveDateTime};
use serde::{Deserialize, Serialize};
use validator::Validate;
/// Model for models.
#[derive(Deserialize, Serialize, Validate)]
pub struct Model {
id: i32,
#[validate(length(min = 2, message = "Can not be empty"))]
name: String,
description: Option<String>,
duration: i32,
height: i32,
weight: i32,
printer: Option<String>,
material: Option<String>,
author_id: i32,
created: NaiveDateTime,
updated: NaiveDateTime,
}
/// Payload used for model creation
#[derive(Deserialize)]
pub struct ModelCreate {
pub name: String,
pub description: Option<String>,
pub duration: i32,
pub height: i32,
pub weight: i32,
pub printer: Option<String>,
pub material: Option<String>,
}
#[derive(Serialize)]
pub struct ModelUser {
id: i32,
name: String,
description: Option<String>,
duration: i32,
height: i32,
weight: i32,
printer: Option<String>,
material: Option<String>,
author_id: i32,
created: NaiveDateTime,
updated: NaiveDateTime,
author: Option<JsonValue>,
}
impl Model {
pub fn new(
name: String,
description: Option<String>,
duration: i32,
height: i32,
weight: i32,
printer: Option<String>,
material: Option<String>,
author_id: i32,
) -> Self {
let now = Local::now().naive_utc();
Self {
id: 0,
name,
description,
duration,
height,
weight,
printer,
material,
author_id,
created: now,
updated: now,
}
}
/// Create a new model
pub async fn create(model: Model) -> Result<Model, AppError> {
let pool = unsafe { get_client() };
model
.validate()
.map_err(|error| AppError::BadRequest(error.to_string()))?;
let rec = sqlx::query_as!(
Model,
r#"
INSERT INTO models (name, description, duration, height, weight, printer, material, author_id, created, updated)
VALUES ( $1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
RETURNING *
"#,
model.name,
model.description,
model.duration,
model.height,
model.weight,
model.printer,
model.material,
model.author_id,
model.created,
model.updated,
)
.fetch_one(pool)
.await?;
Ok(rec)
}
/// Returns the model with id = `model_id`
pub async fn find_by_id(model_id: i32) -> Result<ModelUser, AppError> {
let pool = unsafe { get_client() };
let rec = sqlx::query_as!(
ModelUser,
r#"
SELECT
models.*,
json_build_object('id', users.id, 'email', users.email, 'username', users.username, 'is_staff', users.is_staff) as author
FROM models JOIN users ON users.id = models.author_id
WHERE models.id = $1
"#,
model_id
)
.fetch_one(pool)
.await?;
Ok(rec)
}
/// List all models
pub async fn list(page: i64) -> Result<Vec<ModelUser>, AppError> {
let pool = unsafe { get_client() };
let rows = sqlx::query_as!(
ModelUser,
r#"SELECT
models.*,
json_build_object('id', users.id, 'email', users.email, 'username', users.username, 'is_staff', users.is_staff) as author
FROM models JOIN users ON users.id = models.author_id
LIMIT $1 OFFSET $2
"#,
PAGE_LIMIT,
PAGE_LIMIT * page
)
.fetch_all(pool)
.await?;
Ok(rows)
}
/// Return the number of models.
pub async fn count() -> Result<i64, AppError> {
let pool = unsafe { get_client() };
let row = sqlx::query!(r#"SELECT COUNT(id) as count FROM models"#)
.fetch_one(pool)
.await?;
Ok(row.count.unwrap())
}
}
impl ModelUser {
pub fn author_id(&self) -> JsonValue {
match &self.author {
Some(json) => json.get("id").unwrap().clone(),
None => json!(0),
}
}
}
|
