fmt: cargo fmt

Author: nebocco

atcoder-problems-backend/src/server/auth.rs

@@ -1,9 +1,9 @@
 use crate::server::AppData;
+use actix_web::http::header::LOCATION;
+use actix_web::{cookie::Cookie, error, web, HttpRequest, HttpResponse, Result};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use sql_client::internal::user_manager::UserManager;
-use actix_web::{error, web, HttpRequest, HttpResponse, Result, cookie::Cookie};
-use actix_web::http::header::LOCATION;
 
 const REDIRECT_URL: &str = "https://kenkoooo.com/atcoder/";
 
@@ -51,9 +51,11 @@ impl Authentication for GitHubAuthentication {
             .header("Accept", "application/json")
             .json(&request)
             .send()
-            .await.map_err(error::ErrorInternalServerError)?
+            .await
+            .map_err(error::ErrorInternalServerError)?
             .json()
-            .await.map_err(error::ErrorInternalServerError)?;
+            .await
+            .map_err(error::ErrorInternalServerError)?;
         Ok(response.access_token)
     }
     async fn get_user_id(&self, access_token: &str) -> Result<GitHubUserResponse> {
@@ -63,9 +65,11 @@ impl Authentication for GitHubAuthentication {
             .get("https://api.github.com/user")
             .header("Authorization", token_header)
             .send()
-            .await.map_err(error::ErrorInternalServerError)?
+            .await
+            .map_err(error::ErrorInternalServerError)?
             .json()
-            .await.map_err(error::ErrorInternalServerError)?;
+            .await
+            .map_err(error::ErrorInternalServerError)?;
         Ok(response)
     }
 }
@@ -88,19 +92,28 @@ pub(crate) struct Query {
 pub(crate) async fn get_token<A: Authentication + Clone>(
     _request: HttpRequest,
     data: web::Data<AppData<A>>,
-    query: web::Query<Query>
+    query: web::Query<Query>,
 ) -> Result<HttpResponse> {
     let client = data.authentication.clone();
     let conn = data.pg_pool.clone();
 
-    let token = client.get_token(&query.code).await.map_err(error::ErrorInternalServerError)?;
-    let response = client.get_user_id(&token).await.map_err(error::ErrorInternalServerError)?;
+    let token = client
+        .get_token(&query.code)
+        .await
+        .map_err(error::ErrorInternalServerError)?;
+    let response = client
+        .get_user_id(&token)
+        .await
+        .map_err(error::ErrorInternalServerError)?;
     let internal_user_id = response.id.to_string();
-    conn.register_user(&internal_user_id).await.map_err(error::ErrorInternalServerError)?;
+    conn.register_user(&internal_user_id)
+        .await
+        .map_err(error::ErrorInternalServerError)?;
 
     let cookie = Cookie::build("token", token).path("/").finish();
     let redirect_fragment = query
-        .redirect_to.clone()
+        .redirect_to
+        .clone()
         .unwrap_or_else(|| "/login/user".to_string());
     let redirect_url = format!("{}#{}", REDIRECT_URL, redirect_fragment);
     let response = HttpResponse::Found()

atcoder-problems-backend/src/server/internal_user.rs

@@ -1,8 +1,8 @@
 use crate::server::utils::GetAuthId;
 use crate::server::{AppData, Authentication, CommonResponse};
+use actix_web::{error, web, HttpRequest, HttpResponse, Result};
 use serde::Deserialize;
 use sql_client::internal::user_manager::UserManager;
-use actix_web::{error, web, HttpRequest, HttpResponse, Result};
 
 #[derive(Deserialize)]
 pub(crate) struct Query {
@@ -12,21 +12,25 @@ pub(crate) struct Query {
 pub(crate) async fn update<A: Authentication + Clone + Send + Sync + 'static>(
     request: HttpRequest,
     data: web::Data<AppData<A>>,
-    body: web::Json<Query>
+    body: web::Json<Query>,
 ) -> Result<HttpResponse> {
     let user_id = data.get_authorized_id(request.cookie("token")).await?;
     let conn = data.pg_pool.clone();
     conn.update_internal_user_info(&user_id, &body.atcoder_user_id)
-        .await.map_err(error::ErrorInternalServerError)?;
+        .await
+        .map_err(error::ErrorInternalServerError)?;
     Ok(HttpResponse::empty_json())
 }
 
 pub(crate) async fn get<A: Authentication + Clone + Send + Sync + 'static>(
     request: HttpRequest,
-    data: web::Data<AppData<A>>
+    data: web::Data<AppData<A>>,
 ) -> Result<HttpResponse> {
     let user_id = data.get_authorized_id(request.cookie("token")).await?;
     let conn = data.pg_pool.clone();
-    let info = conn.get_internal_user_info(&user_id).await.map_err(error::ErrorInternalServerError)?;
+    let info = conn
+        .get_internal_user_info(&user_id)
+        .await
+        .map_err(error::ErrorInternalServerError)?;
     Ok(HttpResponse::json(&info)?)
 }

atcoder-problems-backend/src/server/mod.rs

@@ -6,15 +6,15 @@ pub(crate) mod problem_list;
 pub(crate) mod progress_reset;
 pub(crate) mod ranking;
 pub(crate) mod rated_point_sum_ranking;
+pub(crate) mod services;
 pub(crate) mod time_submissions;
 pub(crate) mod user_info;
 pub(crate) mod user_submissions;
 pub(crate) mod utils;
 pub(crate) mod virtual_contest;
-pub(crate) mod services;
 
+use actix_web::{http::header, web, App, HttpResponse, HttpServer};
 pub use auth::{Authentication, GitHubAuthentication, GitHubUserResponse};
-use actix_web::{web, App, HttpServer, HttpResponse, http::header};
 
 pub async fn run_server<A>(
     pg_pool: sql_client::PgPool,
@@ -64,7 +64,7 @@ impl CommonResponse for HttpResponse {
         let mut response = self;
         response.headers_mut().insert(
             header::ACCESS_CONTROL_ALLOW_ORIGIN,
-            header::HeaderValue::from_str("*").unwrap()
+            header::HeaderValue::from_str("*").unwrap(),
         );
         response
     }

atcoder-problems-backend/src/server/progress_reset.rs

@@ -1,16 +1,19 @@
 use crate::server::utils::GetAuthId;
 use crate::server::{AppData, Authentication, CommonResponse};
+use actix_web::{error, web, HttpRequest, HttpResponse, Result};
 use serde::Deserialize;
 use sql_client::internal::progress_reset_manager::ProgressResetManager;
-use actix_web::{web, error, HttpResponse, HttpRequest, Result};
 
 pub(crate) async fn get_progress_reset_list<A: Authentication + Clone + Send + Sync + 'static>(
     request: HttpRequest,
     data: web::Data<AppData<A>>,
 ) -> Result<HttpResponse> {
     let user_id = data.get_authorized_id(request.cookie("token")).await?;
     let conn = data.pg_pool.clone();
-    let list = conn.get_progress_reset_list(&user_id).await.map_err(error::ErrorInternalServerError)?;
+    let list = conn
+        .get_progress_reset_list(&user_id)
+        .await
+        .map_err(error::ErrorInternalServerError)?;
     let response = HttpResponse::json(&list)?;
     Ok(response)
 }
@@ -24,16 +27,13 @@ pub(crate) struct AddItemQuery {
 pub(crate) async fn add_progress_reset_item<A: Authentication + Clone + Send + Sync + 'static>(
     request: HttpRequest,
     data: web::Data<AppData<A>>,
-    query: web::Json<AddItemQuery>
+    query: web::Json<AddItemQuery>,
 ) -> Result<HttpResponse> {
     let user_id = data.get_authorized_id(request.cookie("token")).await?;
     let conn = data.pg_pool.clone();
-    conn.add_item(
-        &user_id,
-        &query.problem_id,
-        query.reset_epoch_second,
-    )
-    .await.map_err(error::ErrorInternalServerError)?;
+    conn.add_item(&user_id, &query.problem_id, query.reset_epoch_second)
+        .await
+        .map_err(error::ErrorInternalServerError)?;
     Ok(HttpResponse::Ok().finish())
 }
 
@@ -42,14 +42,17 @@ pub(crate) struct DeleteItemQuery {
     problem_id: String,
 }
 
-pub(crate) async fn delete_progress_reset_item<A: Authentication + Clone + Send + Sync + 'static>(
+pub(crate) async fn delete_progress_reset_item<
+    A: Authentication + Clone + Send + Sync + 'static,
+>(
     request: HttpRequest,
     data: web::Data<AppData<A>>,
-    query: web::Json<DeleteItemQuery>
+    query: web::Json<DeleteItemQuery>,
 ) -> Result<HttpResponse> {
     let user_id = data.get_authorized_id(request.cookie("token")).await?;
     let conn = data.pg_pool.clone();
     conn.remove_item(&user_id, &query.problem_id)
-        .await.map_err(error::ErrorInternalServerError)?;
+        .await
+        .map_err(error::ErrorInternalServerError)?;
     Ok(HttpResponse::Ok().finish())
 }

atcoder-problems-backend/src/server/ranking/mod.rs

@@ -1,13 +1,13 @@
 use crate::server::{AppData, CommonResponse};
 
 use actix_web::{error, web, HttpRequest, HttpResponse, Result};
+use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use sql_client::accepted_count::AcceptedCountClient;
 use sql_client::language_count::LanguageCountClient;
 use sql_client::rated_point_sum::RatedPointSumClient;
 use sql_client::streak::StreakClient;
 use std::ops::Range;
-use async_trait::async_trait;
 
 #[derive(Deserialize)]
 pub(crate) struct UserRankRequest {
@@ -38,8 +38,15 @@ const MAX_RANKING_RANGE_LENGTH: usize = 1_000;
 // 実行時に問題があるようであれば (?Send) は外し、ranking の引数から request を除けば良さそう
 #[async_trait(?Send)]
 pub(crate) trait RankingSelector<A: Sync + Send + Clone + 'static> {
-    async fn fetch(data: web::Data<AppData<A>>, query: Range<usize>) -> Result<Vec<RankingResponseEntry>>;
-    async fn get_ranking(_request: HttpRequest, data: web::Data<AppData<A>>, query: web::Query<RankingRequest>) -> Result<HttpResponse> {
+    async fn fetch(
+        data: web::Data<AppData<A>>,
+        query: Range<usize>,
+    ) -> Result<Vec<RankingResponseEntry>>;
+    async fn get_ranking(
+        _request: HttpRequest,
+        data: web::Data<AppData<A>>,
+        query: web::Query<RankingRequest>,
+    ) -> Result<HttpResponse> {
         let query = (query.from)..(query.to);
         if query.len() > MAX_RANKING_RANGE_LENGTH {
             return Ok(HttpResponse::BadRequest().finish());
@@ -53,7 +60,11 @@ pub(crate) trait RankingSelector<A: Sync + Send + Clone + 'static> {
 #[async_trait(?Send)]
 pub(crate) trait UserRankSelector<A: Sync + Send + Clone + 'static> {
     async fn fetch(data: web::Data<AppData<A>>, query: &str) -> Result<Option<UserRankResponse>>;
-    async fn get_users_rank(_request: HttpRequest, data: web::Data<AppData<A>>, query: web::Query<UserRankRequest>) -> Result<HttpResponse> {
+    async fn get_users_rank(
+        _request: HttpRequest,
+        data: web::Data<AppData<A>>,
+        query: web::Query<UserRankRequest>,
+    ) -> Result<HttpResponse> {
         let user_rank = Self::fetch(data, &query.user).await?;
         // map と ok_or に書き換えられる
         match user_rank {
@@ -70,7 +81,10 @@ pub(crate) struct StreakRanking;
 
 #[async_trait(?Send)]
 impl<A: Sync + Send + Clone + 'static> RankingSelector<A> for StreakRanking {
-    async fn fetch(data: web::Data<AppData<A>>, query: Range<usize>) -> Result<Vec<RankingResponseEntry>> {
+    async fn fetch(
+        data: web::Data<AppData<A>>,
+        query: Range<usize>,
+    ) -> Result<Vec<RankingResponseEntry>> {
         let conn = data.pg_pool.clone();
         let ranking = conn
             .load_streak_count_in_range(query)
@@ -106,7 +120,10 @@ pub(crate) struct AcRanking;
 
 #[async_trait(?Send)]
 impl<A: Sync + Send + Clone + 'static> RankingSelector<A> for AcRanking {
-    async fn fetch(data: web::Data<AppData<A>>, query: Range<usize>) -> Result<Vec<RankingResponseEntry>> {
+    async fn fetch(
+        data: web::Data<AppData<A>>,
+        query: Range<usize>,
+    ) -> Result<Vec<RankingResponseEntry>> {
         let conn = data.pg_pool.clone();
         let ranking = conn
             .load_accepted_count_in_range(query)