Skip to content

Commit e7eb907

Browse files
nebocconebocco
committed
change: virtual contests with actix-web
1 parent ab988b4 commit e7eb907

File tree

2 files changed

+123
-121
lines changed

2 files changed

+123
-121
lines changed

‎atcoder-problems-backend/src/server/user_submissions.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ pub(crate) async fn get_user_submissions<A>(
2525
.get_submissions(SubmissionRequest::UserAll { user_id })
2626
.await
2727
.map_err(error::ErrorInternalServerError)?;
28-
let mut response = HttpResponse::Ok()
28+
let response = HttpResponse::Ok()
2929
.insert_header((CACHE_CONTROL, "max-age=300"))
3030
.json(&submissions)
3131
.make_cors();

‎atcoder-problems-backend/src/server/virtual_contest.rs

Lines changed: 122 additions & 120 deletions
Original file line numberDiff line numberDiff line change
@@ -1,178 +1,180 @@
1-
use crate::server::utils::RequestUnpack;
1+
use crate::server::utils::GetAuthId;
22
use crate::server::{AppData, Authentication, CommonResponse};
33

4+
use actix_web::{error, web, HttpRequest, HttpResponse, Result};
45
use serde::{Deserialize, Serialize};
56
use sql_client::internal::virtual_contest_manager::{
67
VirtualContestInfo, VirtualContestItem, VirtualContestManager,
78
};
8-
use tide::{Request, Response, Result};
99

10-
pub(crate) async fn create_contest<A>(request: Request<AppData<A>>) -> Result<Response>
11-
where
12-
A: Authentication + Clone + Send + Sync + 'static,
13-
{
14-
#[derive(Deserialize)]
15-
struct Q {
16-
title: String,
17-
memo: String,
18-
start_epoch_second: i64,
19-
duration_second: i64,
20-
mode: Option<String>,
21-
is_public: Option<bool>,
22-
penalty_second: i64,
23-
}
10+
#[derive(Deserialize)]
11+
struct CreateContestQuery {
12+
title: String,
13+
memo: String,
14+
start_epoch_second: i64,
15+
duration_second: i64,
16+
mode: Option<String>,
17+
is_public: Option<bool>,
18+
penalty_second: i64,
19+
}
2420

25-
let user_id = request.get_authorized_id().await?;
26-
let conn = request.state().pg_pool.clone();
27-
let q: Q = request.parse_body().await?;
21+
pub(crate) async fn create_contest<A: Authentication + Clone + Send + Sync + 'static>(
22+
request: HttpRequest,
23+
data: web::Data<AppData<A>>,
24+
query: web::Json<CreateContestQuery>,
25+
) -> Result<HttpResponse> {
26+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
27+
let conn = data.pg_pool.clone();
2828
let contest_id = conn
2929
.create_contest(
30-
&q.title,
31-
&q.memo,
30+
&query.title,
31+
&query.memo,
3232
&user_id,
33-
q.start_epoch_second,
34-
q.duration_second,
35-
q.mode.as_deref(),
36-
q.is_public.unwrap_or(true),
37-
q.penalty_second,
33+
query.start_epoch_second,
34+
query.duration_second,
35+
query.mode.as_deref(),
36+
query.is_public.unwrap_or(true),
37+
query.penalty_second,
3838
)
39-
.await?;
39+
.await.map_err(error::ErrorInternalServerError)?;
4040
let body = serde_json::json!({ "contest_id": contest_id });
41-
let response = Response::json(&body)?;
41+
let response = HttpResponse::json(&body)?;
4242
Ok(response)
4343
}
4444

45-
pub(crate) async fn update_contest<A>(request: Request<AppData<A>>) -> Result<Response>
46-
where
47-
A: Authentication + Clone + Send + Sync + 'static,
48-
{
49-
#[derive(Deserialize)]
50-
struct Q {
51-
id: String,
52-
title: String,
53-
memo: String,
54-
start_epoch_second: i64,
55-
duration_second: i64,
56-
mode: Option<String>,
57-
is_public: Option<bool>,
58-
penalty_second: i64,
59-
}
45+
#[derive(Deserialize)]
46+
struct UpdateContestQuery {
47+
id: String,
48+
title: String,
49+
memo: String,
50+
start_epoch_second: i64,
51+
duration_second: i64,
52+
mode: Option<String>,
53+
is_public: Option<bool>,
54+
penalty_second: i64,
55+
}
6056

61-
request.get_authorized_id().await?;
62-
let conn = request.state().pg_pool.clone();
63-
let q: Q = request.parse_body().await?;
57+
pub(crate) async fn update_contest<A: Authentication + Clone + Send + Sync + 'static>(
58+
request: HttpRequest,
59+
data: web::Data<AppData<A>>,
60+
query: web::Json<UpdateContestQuery>,
61+
) -> Result<HttpResponse> {
62+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
63+
let conn = data.pg_pool.clone();
6464
conn.update_contest(
65-
&q.id,
66-
&q.title,
67-
&q.memo,
68-
q.start_epoch_second,
69-
q.duration_second,
70-
q.mode.as_deref(),
71-
q.is_public.unwrap_or(true),
72-
q.penalty_second,
65+
&query.id,
66+
&query.title,
67+
&query.memo,
68+
query.start_epoch_second,
69+
query.duration_second,
70+
query.mode.as_deref(),
71+
query.is_public.unwrap_or(true),
72+
query.penalty_second,
7373
)
74-
.await?;
75-
let response = Response::empty_json();
74+
.await.map_err(error::ErrorInternalServerError)?;
75+
let response = HttpResponse::empty_json();
7676
Ok(response)
7777
}
7878

79-
pub(crate) async fn update_items<A: Authentication + Clone + Send + Sync + 'static>(
80-
request: Request<AppData<A>>,
81-
) -> Result<Response> {
82-
#[derive(Deserialize)]
83-
struct Q {
84-
contest_id: String,
85-
problems: Vec<VirtualContestItem>,
86-
}
79+
#[derive(Deserialize)]
80+
struct UpdateItemsQuery {
81+
contest_id: String,
82+
problems: Vec<VirtualContestItem>,
83+
}
8784

88-
let user_id = request.get_authorized_id().await?;
89-
let conn = request.state().pg_pool.clone();
90-
let q: Q = request.parse_body().await?;
91-
conn.update_items(&q.contest_id, &q.problems, &user_id)
92-
.await?;
93-
let response = Response::empty_json();
85+
pub(crate) async fn update_items<A: Authentication + Clone + Send + Sync + 'static>(
86+
request: HttpRequest,
87+
data: web::Data<AppData<A>>,
88+
query: web::Json<UpdateItemsQuery>,
89+
) -> Result<HttpResponse> {
90+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
91+
let conn = data.pg_pool.clone();
92+
conn.update_items(&query.contest_id, &query.problems, &user_id)
93+
.await.map_err(error::ErrorInternalServerError)?;
94+
let response = HttpResponse::empty_json();
9495
Ok(response)
9596
}
9697

9798
pub(crate) async fn get_my_contests<A: Authentication + Clone + Send + Sync + 'static>(
98-
request: Request<AppData<A>>,
99-
) -> Result<Response> {
100-
let user_id = request.get_authorized_id().await?;
101-
let conn = request.state().pg_pool.clone();
102-
let contests = conn.get_own_contests(&user_id).await?;
103-
let response = Response::json(&contests)?;
99+
request: HttpRequest,
100+
data: web::Data<AppData<A>>,
101+
) -> Result<HttpResponse> {
102+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
103+
let conn = data.pg_pool.clone();
104+
let contests = conn.get_own_contests(&user_id).await.map_err(error::ErrorInternalServerError)?;
105+
let response = HttpResponse::json(&contests)?;
104106
Ok(response)
105107
}
106108

107109
pub(crate) async fn get_participated<A: Authentication + Clone + Send + Sync + 'static>(
108-
request: Request<AppData<A>>,
109-
) -> Result<Response> {
110-
let user_id = request.get_authorized_id().await?;
111-
let conn = request.state().pg_pool.clone();
112-
let contests = conn.get_participated_contests(&user_id).await?;
113-
let response = Response::json(&contests)?;
110+
request: HttpRequest,
111+
data: web::Data<AppData<A>>,
112+
) -> Result<HttpResponse> {
113+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
114+
let conn = data.pg_pool.clone();
115+
let contests = conn.get_participated_contests(&user_id).await.map_err(error::ErrorInternalServerError)?;
116+
let response = HttpResponse::json(&contests)?;
114117
Ok(response)
115118
}
116119

117-
pub(crate) async fn get_single_contest<A>(request: Request<AppData<A>>) -> Result<Response>
118-
where
119-
A: Authentication + Clone + Send + Sync + 'static,
120-
{
120+
#[derive(Deserialize)]
121+
struct SingleContestQuery {
122+
contest_id: String
123+
}
124+
125+
pub(crate) async fn get_single_contest<A: Authentication + Clone + Send + Sync + 'static>(
126+
request: HttpRequest,
127+
data: web::Data<AppData<A>>,
128+
query: web::Query<SingleContestQuery>,
129+
) -> Result<HttpResponse> {
121130
#[derive(Serialize)]
122131
struct VirtualContestDetails {
123132
info: VirtualContestInfo,
124133
problems: Vec<VirtualContestItem>,
125134
participants: Vec<String>,
126135
}
127-
128-
let conn = request.state().pg_pool.clone();
129-
let contest_id = request.param("contest_id")?;
130-
131-
let info = conn.get_single_contest_info(contest_id).await?;
132-
let participants = conn.get_single_contest_participants(contest_id).await?;
133-
let problems = conn.get_single_contest_problems(contest_id).await?;
136+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
137+
let conn = data.pg_pool.clone();
138+
let contest_id = &query.contest_id;
139+
let info = conn.get_single_contest_info(contest_id).await.map_err(error::ErrorInternalServerError)?;
140+
let participants = conn.get_single_contest_participants(contest_id).await.map_err(error::ErrorInternalServerError)?;
141+
let problems = conn.get_single_contest_problems(contest_id).await.map_err(error::ErrorInternalServerError)?;
134142
let contest = VirtualContestDetails {
135143
info,
136144
problems,
137145
participants,
138146
};
139-
let response = Response::json(&contest)?;
147+
let response = HttpResponse::json(&contest)?;
140148
Ok(response)
141149
}
142150

143-
pub(crate) async fn get_recent_contests<A>(request: Request<AppData<A>>) -> Result<Response> {
144-
let conn = request.state().pg_pool.clone();
145-
let contest = conn.get_recent_contest_info().await?;
146-
let response = Response::json(&contest)?;
151+
pub(crate) async fn get_recent_contests<A>(request: HttpRequest, data: web::Data<AppData<A>>) -> Result<HttpResponse> {
152+
let conn = data.pg_pool.clone();
153+
let contest = conn.get_recent_contest_info().await.map_err(error::ErrorInternalServerError)?;
154+
let response = HttpResponse::json(&contest)?;
147155
Ok(response)
148156
}
149157

150158
pub(crate) async fn join_contest<A: Authentication + Clone + Send + Sync + 'static>(
151-
request: Request<AppData<A>>,
152-
) -> Result<Response> {
153-
#[derive(Deserialize)]
154-
struct Q {
155-
contest_id: String,
156-
}
157-
let user_id = request.get_authorized_id().await?;
158-
let conn = request.state().pg_pool.clone();
159-
let q: Q = request.parse_body().await?;
160-
conn.join_contest(&q.contest_id, &user_id).await?;
161-
let response = Response::empty_json();
159+
request: HttpRequest,
160+
data: web::Data<AppData<A>>,
161+
query: web::Json<SingleContestQuery>,
162+
) -> Result<HttpResponse> {
163+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
164+
let conn = data.pg_pool.clone();
165+
conn.join_contest(&query.contest_id, &user_id).await.map_err(error::ErrorInternalServerError)?;
166+
let response = HttpResponse::empty_json();
162167
Ok(response)
163168
}
164169

165170
pub(crate) async fn leave_contest<A: Authentication + Clone + Send + Sync + 'static>(
166-
request: Request<AppData<A>>,
167-
) -> Result<Response> {
168-
#[derive(Deserialize)]
169-
struct Q {
170-
contest_id: String,
171-
}
172-
let user_id = request.get_authorized_id().await?;
173-
let conn = request.state().pg_pool.clone();
174-
let q: Q = request.parse_body().await?;
175-
conn.leave_contest(&q.contest_id, &user_id).await?;
176-
let response = Response::empty_json();
171+
request: HttpRequest,
172+
data: web::Data<AppData<A>>,
173+
query: web::Json<SingleContestQuery>,
174+
) -> Result<HttpResponse> {
175+
let user_id = data.get_authorized_id(request.cookie("token")).await?;
176+
let conn = data.pg_pool.clone();
177+
conn.leave_contest(&query.contest_id, &user_id).await.map_err(error::ErrorInternalServerError)?;
178+
let response = HttpResponse::empty_json();
177179
Ok(response)
178180
}

0 commit comments

Comments
 (0)