Skip to content

Commit ab4c2c8

Browse files
manglemixmanglemix
committed
changed backend api
1 parent f58aeb1 commit ab4c2c8

File tree

1 file changed

+125
-78
lines changed

1 file changed

+125
-78
lines changed

‎usr-backend/src/manifest.rs‎

Lines changed: 125 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,14 @@
11
use axum::{
2-
extract::State, http::StatusCode, response::{IntoResponse, Response}, routing::{delete, get, post}, Json, Router
2+
extract::State,
3+
http::StatusCode,
4+
response::{IntoResponse, Response},
5+
routing::{delete, get, post},
6+
Json, Router,
37
};
48
use sea_orm::{
5-
prelude::Decimal, sea_query::Table, sqlx::types::chrono::Local, ActiveModelTrait, ActiveValue, ColumnTrait, ConnectionTrait, DatabaseConnection, EntityTrait, QueryFilter, QueryOrder, Schema, TransactionTrait
9+
prelude::Decimal, sea_query::Table, sqlx::types::chrono::Local, ActiveModelTrait, ActiveValue,
10+
ColumnTrait, ConnectionTrait, DatabaseConnection, EntityTrait, QueryFilter, QueryOrder, Schema,
11+
TransactionTrait,
612
};
713
use serde::Deserialize;
814
use tracing::error;
@@ -52,25 +58,33 @@ async fn new_order(
5258
link: ActiveValue::Set(pending_order.link),
5359
ref_number: ActiveValue::NotSet,
5460
};
55-
let result = state.db.transaction(|tx| Box::pin(async move {
56-
let model = active_model.insert(tx).await?;
61+
let result = state
62+
.db
63+
.transaction(|tx| {
64+
Box::pin(async move {
65+
let model = active_model.insert(tx).await?;
5766

58-
let active_model = order_status::ActiveModel {
59-
order_id: ActiveValue::Set(model.id),
60-
instance_id: ActiveValue::NotSet,
61-
date: ActiveValue::Set(Local::now().naive_local()),
62-
status: ActiveValue::Set(order_status::Status::New),
63-
};
67+
let active_model = order_status::ActiveModel {
68+
order_id: ActiveValue::Set(model.id),
69+
instance_id: ActiveValue::NotSet,
70+
date: ActiveValue::Set(Local::now().naive_local()),
71+
status: ActiveValue::Set(order_status::Status::New),
72+
};
6473

65-
active_model.insert(tx).await?;
74+
active_model.insert(tx).await?;
6675

67-
Result::<_, sea_orm::DbErr>::Ok(model)
68-
})).await;
76+
Result::<_, sea_orm::DbErr>::Ok(model)
77+
})
78+
})
79+
.await;
6980

7081
match result {
71-
Ok(m) => {
82+
Ok(m) => {
7283
backup_db(state);
73-
state.new_orders_webhook.as_ref().map(|x| x.enqueue(m.id, webhook_msg));
84+
state
85+
.new_orders_webhook
86+
.as_ref()
87+
.map(|x| x.enqueue(m.id, webhook_msg));
7488
(StatusCode::OK, "")
7589
}
7690
Err(e) => {
@@ -91,15 +105,19 @@ pub struct ChangeOrder {
91105
pub reason: String,
92106
pub vendor: String,
93107
pub link: String,
94-
pub ref_number: Option<u32>
95108
}
96109

97110
#[axum::debug_handler]
98111
async fn change_order(
99112
State(state): State<&'static UsrState>,
100113
Json(change_order): Json<ChangeOrder>,
101114
) -> (StatusCode, &'static str) {
102-
match order_status::Entity::find().filter(order_status::Column::OrderId.eq(change_order.id)).order_by_desc(order_status::Column::InstanceId).one(&state.db).await {
115+
match order_status::Entity::find()
116+
.filter(order_status::Column::OrderId.eq(change_order.id))
117+
.order_by_desc(order_status::Column::InstanceId)
118+
.one(&state.db)
119+
.await
120+
{
103121
Ok(Some(model)) => {
104122
if model.status != order_status::Status::New {
105123
return (StatusCode::BAD_REQUEST, "Order has already been processed");
@@ -134,32 +152,17 @@ async fn change_order(
134152
reason: ActiveValue::Set(change_order.reason),
135153
vendor: ActiveValue::Set(change_order.vendor),
136154
link: ActiveValue::Set(change_order.link),
137-
ref_number: ActiveValue::Set(change_order.ref_number)
155+
ref_number: ActiveValue::NotSet,
138156
};
139157
if let Err(e) = active_model.update(&state.db).await {
140158
error!("Failed to change order: {e}");
141159
(StatusCode::INTERNAL_SERVER_ERROR, "")
142160
} else {
143161
backup_db(state);
144-
state.new_orders_webhook.as_ref().map(|x| x.enqueue(change_order.id, webhook_msg));
145-
// let mut guard = BATCHED.lock();
146-
// match guard.queue.entry(change_order.id) {
147-
// Entry::Occupied(mut entry) => {
148-
// entry.insert(webhook_msg);
149-
// }
150-
// Entry::Vacant(_) => {
151-
// tokio::spawn(async move {
152-
// let Some(new_orders_webhook) = state.new_orders_webhook.as_ref() else { return; };
153-
// if let Err(e) = new_orders_webhook
154-
// .send(&Message::new(|message| message.content(webhook_msg)))
155-
// .await
156-
// {
157-
// error!("Failed to trigger new-order webhook: {e}");
158-
// }
159-
// });
160-
// }
161-
// }
162-
162+
state
163+
.new_orders_webhook
164+
.as_ref()
165+
.map(|x| x.enqueue(change_order.id, webhook_msg));
163166
(StatusCode::OK, "")
164167
}
165168
}
@@ -168,7 +171,7 @@ async fn change_order(
168171
struct DeleteOrder {
169172
id: u32,
170173
#[serde(default)]
171-
force: bool
174+
force: bool,
172175
}
173176

174177
#[axum::debug_handler]
@@ -178,7 +181,12 @@ async fn cancel_order(
178181
) -> (StatusCode, &'static str) {
179182
let webhook_msg;
180183

181-
match order_status::Entity::find().filter(order_status::Column::OrderId.eq(id)).order_by_desc(order_status::Column::InstanceId).one(&state.db).await {
184+
match order_status::Entity::find()
185+
.filter(order_status::Column::OrderId.eq(id))
186+
.order_by_desc(order_status::Column::InstanceId)
187+
.one(&state.db)
188+
.await
189+
{
182190
Ok(Some(model)) => {
183191
if !force && model.status != order_status::Status::New {
184192
return (StatusCode::BAD_REQUEST, "Order has already been processed");
@@ -193,9 +201,7 @@ async fn cancel_order(
193201
};
194202
webhook_msg = format!(
195203
"***Order Cancelled***\n**Name:** {}\n**Count:** {}\n**Team:** {}",
196-
model.name,
197-
model.count,
198-
model.team,
204+
model.name, model.count, model.team,
199205
);
200206
}
201207
Ok(None) => {
@@ -208,23 +214,33 @@ async fn cancel_order(
208214
}
209215

210216
if force {
211-
let result = state.db.transaction(|tx| Box::pin(async move {
212-
order::Entity::delete_by_id(id).exec(tx).await?;
213-
order_status::Entity::delete_many().filter(order_status::Column::OrderId.eq(id)).exec(tx).await?;
214-
Result::<_, sea_orm::DbErr>::Ok(())
215-
})).await;
217+
let result = state
218+
.db
219+
.transaction(|tx| {
220+
Box::pin(async move {
221+
order::Entity::delete_by_id(id).exec(tx).await?;
222+
order_status::Entity::delete_many()
223+
.filter(order_status::Column::OrderId.eq(id))
224+
.exec(tx)
225+
.await?;
226+
Result::<_, sea_orm::DbErr>::Ok(())
227+
})
228+
})
229+
.await;
216230

217231
if let Err(e) = result {
218232
error!("Failed to force delete order: {e}");
219233
return (StatusCode::INTERNAL_SERVER_ERROR, "");
220234
}
221-
222235
} else if let Err(e) = order::Entity::delete_by_id(id).exec(&state.db).await {
223236
error!("Failed to delete order: {e}");
224237
return (StatusCode::INTERNAL_SERVER_ERROR, "");
225238
}
226239

227-
state.new_orders_webhook.as_ref().map(|x| x.enqueue(id, webhook_msg));
240+
state
241+
.new_orders_webhook
242+
.as_ref()
243+
.map(|x| x.enqueue(id, webhook_msg));
228244
backup_db(state);
229245

230246
(StatusCode::OK, "")
@@ -233,7 +249,8 @@ async fn cancel_order(
233249
#[derive(Deserialize)]
234250
pub struct UpdateOrder {
235251
pub id: u32,
236-
pub status: order_status::Status
252+
pub status: order_status::Status,
253+
pub ref_number: Option<u32>,
237254
}
238255

239256
#[axum::debug_handler]
@@ -243,15 +260,23 @@ async fn update_order(
243260
) -> (StatusCode, &'static str) {
244261
let webhook_msg;
245262

246-
match order_status::Entity::find().filter(order_status::Column::OrderId.eq(update_order.id)).order_by_desc(order_status::Column::InstanceId).one(&state.db).await {
263+
match order_status::Entity::find()
264+
.filter(order_status::Column::OrderId.eq(update_order.id))
265+
.order_by_desc(order_status::Column::InstanceId)
266+
.one(&state.db)
267+
.await
268+
{
247269
Ok(Some(model)) => {
248270
if model.status == order_status::Status::InStorage {
249271
return (StatusCode::BAD_REQUEST, "Order is already in storage");
250272
}
251273
if model.status == update_order.status {
252274
return (StatusCode::BAD_REQUEST, "Order is already in that state");
253275
}
254-
let model = match order::Entity::find_by_id(update_order.id).one(&state.db).await {
276+
let model = match order::Entity::find_by_id(update_order.id)
277+
.one(&state.db)
278+
.await
279+
{
255280
Ok(Some(model)) => model,
256281
Ok(None) => unreachable!(),
257282
Err(e) => {
@@ -263,23 +288,18 @@ async fn update_order(
263288
if model.store_in.is_empty() {
264289
webhook_msg = format!(
265290
"**Order Complete!**\n**Name:** {}\n**Team:** {}",
266-
model.name,
267-
model.team
291+
model.name, model.team
268292
);
269293
} else {
270294
webhook_msg = format!(
271295
"**Order Complete!**\n**Name:** {}\n**Team:** {}\n**Location:** {}",
272-
model.name,
273-
model.team,
274-
model.store_in
296+
model.name, model.team, model.store_in
275297
);
276298
}
277299
} else {
278300
webhook_msg = format!(
279301
"**Order Update!**\n**Name:** {}\n**Team:** {}\n**Status:** {}",
280-
model.name,
281-
model.team,
282-
update_order.status
302+
model.name, model.team, update_order.status
283303
);
284304
}
285305
}
@@ -291,40 +311,67 @@ async fn update_order(
291311
return (StatusCode::INTERNAL_SERVER_ERROR, "");
292312
}
293313
}
294-
295-
let active_model = order_status::ActiveModel {
296-
order_id: ActiveValue::Set(update_order.id),
297-
instance_id: ActiveValue::NotSet,
298-
date: ActiveValue::Set(Local::now().naive_local()),
299-
status: ActiveValue::Set(update_order.status),
300-
};
301-
if let Err(e) = active_model.insert(&state.db).await {
314+
315+
let result = state
316+
.db
317+
.transaction(|tx| {
318+
Box::pin(async move {
319+
let active_model = order_status::ActiveModel {
320+
order_id: ActiveValue::Set(update_order.id),
321+
instance_id: ActiveValue::NotSet,
322+
date: ActiveValue::Set(Local::now().naive_local()),
323+
status: ActiveValue::Set(update_order.status),
324+
};
325+
326+
active_model.insert(tx).await?;
327+
328+
let active_model = order::ActiveModel {
329+
id: ActiveValue::Unchanged(update_order.id),
330+
name: ActiveValue::NotSet,
331+
count: ActiveValue::NotSet,
332+
unit_cost: ActiveValue::NotSet,
333+
store_in: ActiveValue::NotSet,
334+
team: ActiveValue::NotSet,
335+
reason: ActiveValue::NotSet,
336+
vendor: ActiveValue::NotSet,
337+
link: ActiveValue::NotSet,
338+
ref_number: ActiveValue::Set(update_order.ref_number),
339+
};
340+
341+
active_model.insert(tx).await?;
342+
343+
Result::<_, sea_orm::DbErr>::Ok(())
344+
})
345+
})
346+
.await;
347+
348+
if let Err(e) = result {
302349
error!("Failed to update order status: {e}");
303350
(StatusCode::INTERNAL_SERVER_ERROR, "")
304351
} else {
305-
state.order_updates_webhook.as_ref().map(|x| x.enqueue(update_order.id, webhook_msg));
352+
state
353+
.order_updates_webhook
354+
.as_ref()
355+
.map(|x| x.enqueue(update_order.id, webhook_msg));
306356
backup_db(state);
307357
(StatusCode::OK, "")
308358
}
309359
}
310360

311361
#[axum::debug_handler]
312-
async fn get_orders(
313-
State(state): State<&'static UsrState>,
314-
) -> Response {
362+
async fn get_orders(State(state): State<&'static UsrState>) -> Response {
315363
let result = order::Entity::find().all(&state.db).await;
316364

317365
match result {
318366
Ok(orders) => {
319367
let result = order_status::Entity::find().all(&state.db).await;
320368

321369
match result {
322-
Ok(statuses) => {
323-
Json(serde_json::json!({
324-
"orders": orders,
325-
"statuses": statuses
326-
})).into_response()
327-
}
370+
Ok(statuses) => Json(serde_json::json!({
371+
"orders": orders,
372+
"statuses": statuses
373+
}))
374+
.into_response(),
328375
Err(e) => {
329376
error!("Failed to get orders: {e}");
330377
(StatusCode::INTERNAL_SERVER_ERROR, "").into_response()

0 commit comments

Comments
 (0)