Refactoring authentication

Author: kenkoooo

atcoder-problems-backend/Cargo.lock

@@ -24,14 +24,17 @@ sql-client = { path = "./sql-client" }
 atcoder-client = { path = "./atcoder-client" }
 
 # Web framework
-actix-web = "4.0.0-beta.18"
+actix-web = "4.0.0-rc.2"
+actix-service = "2.0.2"
 reqwest = { version = "0.11", features = ["json"] }
 
 async-trait = "0.1"
 
 anyhow = "1.0"
+futures-util = "0.3.19"
 
 [dev-dependencies]
+httpmock = "0.6.6"
 
 [workspace]
 members = ["sql-client", "atcoder-client"]

atcoder-problems-backend/Cargo.toml

@@ -1,24 +1,24 @@
 use std::env;
 
+use atcoder_problems_backend::server::middleware::github_auth::GithubClient;
 use atcoder_problems_backend::server::run_server;
-use atcoder_problems_backend::server::GitHubAuthentication;
 use atcoder_problems_backend::utils::init_log_config;
 
 #[actix_web::main]
 async fn main() {
-    // std::env::set_var("RUST_LOG", "actix_web=info");
     init_log_config().unwrap();
     let database_url = env::var("SQL_URL").expect("SQL_URL is not set.");
     let port = 8080;
 
     let client_id = env::var("CLIENT_ID").unwrap_or_else(|_| String::new());
     let client_secret = env::var("CLIENT_SECRET").unwrap_or_else(|_| String::new());
 
-    let auth = GitHubAuthentication::new(&client_id, &client_secret);
     let pg_pool = sql_client::initialize_pool(&database_url)
         .await
         .expect("Failed to initialize the connection pool");
-    run_server(pg_pool, auth, port)
+    let github = GithubClient::new(&client_id, &client_secret, "https://api.github.com")
+        .expect("Failed to create github client");
+    run_server(pg_pool, github, port)
         .await
         .expect("Failed to run server");
 }

atcoder-problems-backend/src/bin/run_server.rs

@@ -1,11 +1,6 @@
-use crate::server::AppData;
-use actix_web::http::header::LOCATION;
-use actix_web::{cookie::Cookie, error, web, HttpRequest, HttpResponse, Result};
+use actix_web::{error, Result};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
-use sql_client::internal::user_manager::UserManager;
-
-const REDIRECT_URL: &str = "https://kenkoooo.com/atcoder/";
 
 #[async_trait(?Send)]
 pub trait Authentication {
@@ -84,43 +79,3 @@ impl GitHubAuthentication {
         }
     }
 }
-
-#[derive(Deserialize)]
-pub(crate) struct Query {
-    code: String,
-    redirect_to: Option<String>,
-}
-
-pub(crate) async fn get_token<A: Authentication + Clone>(
-    _request: HttpRequest,
-    data: web::Data<AppData<A>>,
-    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 internal_user_id = response.id.to_string();
-    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()
-        .unwrap_or_else(|| "/login/user".to_string());
-    let redirect_url = format!("{}#{}", REDIRECT_URL, redirect_fragment);
-    let response = HttpResponse::Found()
-        .insert_header((LOCATION, redirect_url))
-        .cookie(cookie)
-        .finish();
-    Ok(response)
-}

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

@@ -0,0 +1,6 @@
+use actix_web::{get, HttpResponse, Responder};
+
+#[get("/healthcheck")]
+pub async fn get_healthcheck() -> impl Responder {
+    HttpResponse::Ok().finish()
+}

atcoder-problems-backend/src/server/endpoint/healthcheck.rs

@@ -0,0 +1,28 @@
+use actix_web::{post, web, HttpResponse, Responder, Result};
+use serde::Deserialize;
+use sql_client::{
+    internal::virtual_contest_manager::{VirtualContestItem, VirtualContestManager},
+    PgPool,
+};
+
+use crate::server::{error::ApiResult, middleware::github_auth::GithubToken};
+
+#[derive(Deserialize)]
+pub struct UpdateItemsQuery {
+    contest_id: String,
+    problems: Vec<VirtualContestItem>,
+}
+
+#[post("/internal-api/contest/item/update")]
+pub async fn update_items(
+    token: web::ReqData<GithubToken>,
+    pool: web::Data<PgPool>,
+    query: web::Json<UpdateItemsQuery>,
+) -> Result<impl Responder> {
+    let user_id = token.id.to_string();
+    pool.update_items(&query.contest_id, &query.problems, &user_id)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().finish();
+    Ok(response)
+}

atcoder-problems-backend/src/server/endpoint/internal_api/contest/item.rs

@@ -0,0 +1,186 @@
+pub mod item;
+
+use actix_web::{get, post, web, HttpResponse, Responder, Result};
+use serde::{Deserialize, Serialize};
+use sql_client::{
+    internal::virtual_contest_manager::{
+        VirtualContestInfo, VirtualContestItem, VirtualContestManager,
+    },
+    PgPool,
+};
+
+use crate::server::{error::ApiResult, middleware::github_auth::GithubToken};
+
+#[derive(Deserialize)]
+pub struct CreateContestQuery {
+    title: String,
+    memo: String,
+    start_epoch_second: i64,
+    duration_second: i64,
+    mode: Option<String>,
+    is_public: Option<bool>,
+    penalty_second: i64,
+}
+
+#[post("/internal-api/contest/create")]
+pub async fn create_contest(
+    token: web::ReqData<GithubToken>,
+    pool: web::Data<PgPool>,
+    query: web::Json<CreateContestQuery>,
+) -> Result<impl Responder> {
+    let user_id = token.id.to_string();
+    let contest_id = pool
+        .create_contest(
+            &query.title,
+            &query.memo,
+            &user_id,
+            query.start_epoch_second,
+            query.duration_second,
+            query.mode.as_deref(),
+            query.is_public.unwrap_or(true),
+            query.penalty_second,
+        )
+        .await
+        .map_internal_server_err()?;
+    let body = serde_json::json!({ "contest_id": contest_id });
+    let response = HttpResponse::Ok().json(&body);
+    Ok(response)
+}
+
+#[derive(Deserialize)]
+pub struct UpdateContestQuery {
+    id: String,
+    title: String,
+    memo: String,
+    start_epoch_second: i64,
+    duration_second: i64,
+    mode: Option<String>,
+    is_public: Option<bool>,
+    penalty_second: i64,
+}
+
+#[post("/internal-api/contest/update")]
+pub async fn update_contest(
+    _: web::ReqData<GithubToken>,
+    pool: web::Data<PgPool>,
+    query: web::Json<UpdateContestQuery>,
+) -> Result<impl Responder> {
+    // TODO authorize
+    pool.update_contest(
+        &query.id,
+        &query.title,
+        &query.memo,
+        query.start_epoch_second,
+        query.duration_second,
+        query.mode.as_deref(),
+        query.is_public.unwrap_or(true),
+        query.penalty_second,
+    )
+    .await
+    .map_internal_server_err()?;
+    let response = HttpResponse::Ok().finish();
+    Ok(response)
+}
+
+#[get("/internal-api/contest/get/{contest_id}")]
+pub async fn get_single_contest(
+    pool: web::Data<PgPool>,
+    contest_id: web::Path<String>,
+) -> Result<HttpResponse> {
+    #[derive(Serialize)]
+    struct VirtualContestDetails {
+        info: VirtualContestInfo,
+        problems: Vec<VirtualContestItem>,
+        participants: Vec<String>,
+    }
+    let info = pool
+        .get_single_contest_info(&contest_id)
+        .await
+        .map_internal_server_err()?;
+    let participants = pool
+        .get_single_contest_participants(&contest_id)
+        .await
+        .map_internal_server_err()?;
+    let problems = pool
+        .get_single_contest_problems(&contest_id)
+        .await
+        .map_internal_server_err()?;
+    let contest = VirtualContestDetails {
+        info,
+        problems,
+        participants,
+    };
+    let response = HttpResponse::Ok().json(&contest);
+    Ok(response)
+}
+
+#[derive(Deserialize)]
+pub struct SingleContestQuery {
+    contest_id: String,
+}
+
+#[post("/internal-api/contest/join")]
+pub async fn join_contest(
+    token: web::ReqData<GithubToken>,
+    pool: web::Data<PgPool>,
+    query: web::Json<SingleContestQuery>,
+) -> Result<HttpResponse> {
+    let user_id = token.id.to_string();
+    pool.join_contest(&query.contest_id, &user_id)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().finish();
+    Ok(response)
+}
+
+#[post("/internal-api/contest/leave")]
+pub async fn leave_contest(
+    token: web::ReqData<GithubToken>,
+    pool: web::Data<PgPool>,
+    query: web::Json<SingleContestQuery>,
+) -> Result<HttpResponse> {
+    let user_id = token.id.to_string();
+    pool.leave_contest(&query.contest_id, &user_id)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().finish();
+    Ok(response)
+}
+
+#[get("/internal-api/contest/my")]
+pub async fn get_my_contests(
+    token: web::ReqData<GithubToken>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse> {
+    let user_id = token.id.to_string();
+    let contests = pool
+        .get_own_contests(&user_id)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().json(&contests);
+    Ok(response)
+}
+
+#[get("/internal-api/contest/joined")]
+pub async fn get_participated(
+    token: web::ReqData<GithubToken>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse> {
+    let user_id = token.id.to_string();
+    let contests = pool
+        .get_participated_contests(&user_id)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().json(&contests);
+    Ok(response)
+}
+
+#[get("/internal-api/contest/recent")]
+pub async fn get_recent_contests(pool: web::Data<PgPool>) -> Result<HttpResponse> {
+    let contest = pool
+        .get_recent_contest_info()
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().json(&contest);
+    Ok(response)
+}

atcoder-problems-backend/src/server/endpoint/internal_api/contest/mod.rs

@@ -0,0 +1,66 @@
+use actix_web::{post, web, HttpResponse, Responder, Result};
+use serde::Deserialize;
+use sql_client::{internal::problem_list_manager::ProblemListManager, PgPool};
+
+use crate::server::{error::ApiResult, middleware::github_auth::GithubToken};
+
+#[derive(Deserialize)]
+pub struct AddItemQuery {
+    internal_list_id: String,
+    problem_id: String,
+}
+
+#[post("/internal-api/list/item/add")]
+pub async fn add_item(
+    query: web::Json<AddItemQuery>,
+    pool: web::Data<PgPool>,
+    _: web::ReqData<GithubToken>,
+) -> Result<impl Responder> {
+    // TODO authorize
+    pool.add_item(&query.internal_list_id, &query.problem_id)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().finish();
+    Ok(response)
+}
+
+#[derive(Deserialize)]
+pub struct UpdateItemQuery {
+    internal_list_id: String,
+    problem_id: String,
+    memo: String,
+}
+
+#[post("/internal-api/list/item/update")]
+pub async fn update_item(
+    query: web::Json<UpdateItemQuery>,
+    pool: web::Data<PgPool>,
+    _: web::ReqData<GithubToken>,
+) -> Result<impl Responder> {
+    // TODO authorize
+    pool.update_item(&query.internal_list_id, &query.problem_id, &query.memo)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().finish();
+    Ok(response)
+}
+
+#[derive(Deserialize)]
+pub struct DeleteItemQuery {
+    internal_list_id: String,
+    problem_id: String,
+}
+
+#[post("/internal-api/list/item/delete")]
+pub async fn delete_item(
+    query: web::Json<DeleteItemQuery>,
+    pool: web::Data<PgPool>,
+    _: web::ReqData<GithubToken>,
+) -> Result<impl Responder> {
+    // TODO authorize
+    pool.delete_item(&query.internal_list_id, &query.problem_id)
+        .await
+        .map_internal_server_err()?;
+    let response = HttpResponse::Ok().finish();
+    Ok(response)
+}