From 7f61933184597c35e60bfc0227a0278f5e3eefb7 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 11 Oct 2024 18:09:31 +0530
Subject: [PATCH 01/33] feat: updated backend response for profile endpoint

---
 frontend/src/types/backend.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/frontend/src/types/backend.ts b/frontend/src/types/backend.ts
index 0e0c82f..d63a9ef 100644
--- a/frontend/src/types/backend.ts
+++ b/frontend/src/types/backend.ts
@@ -62,6 +62,7 @@ export interface IEndpointTypes {
 		request: null;
 		response: {
 			username: string;
+			token: string;
 		}
 	},
 	similar: {

From e5fc090070411350b48a93f409663495032fb082 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 11 Oct 2024 18:34:04 +0530
Subject: [PATCH 02/33] feat: added db fn to get paper by id

---
 backend-rs/src/db.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/backend-rs/src/db.rs b/backend-rs/src/db.rs
index 120d305..b467ec4 100644
--- a/backend-rs/src/db.rs
+++ b/backend-rs/src/db.rs
@@ -66,6 +66,14 @@ impl Database {
             .map(|qp| qp::SearchQP::from(qp.clone()))
             .collect())
     }
+
+    pub async fn get_paper_by_id(&self, id: i32) -> Result<qp::AdminDashboardQP, sqlx::Error> {
+        let query = sqlx::query_as(queries::GET_PAPER_BY_ID).bind(id);
+
+        let paper: models::DBAdminDashboardQP = query.fetch_one(&self.connection).await?;
+
+        Ok(paper.into())
+    }
 }
 
 mod models {
@@ -134,6 +142,9 @@ mod models {
 }
 
 mod queries {
+    /// Get a paper ([`crate::db::models::DBAdminDashboardQP`]) with the given id (first parameter `$1`)
+    pub const GET_PAPER_BY_ID: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE id = $1";
+
     /// Gets all unapproved papers ([`crate::db::models::DBAdminDashboardQP`]) from the database
     pub const GET_ALL_UNAPPROVED: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE approve_status = false and is_deleted=false ORDER BY upload_timestamp ASC";
 

From b5e29fdf5c23bc44407c629a71fb03c6a797daa3 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 11 Oct 2024 21:51:29 +0530
Subject: [PATCH 03/33] refactor:  split routing into separate files

---
 backend-rs/src/routing.rs            | 343 ---------------------------
 backend-rs/src/routing/handlers.rs   | 127 ++++++++++
 backend-rs/src/routing/middleware.rs |  52 ++++
 backend-rs/src/routing/mod.rs        | 157 ++++++++++++
 4 files changed, 336 insertions(+), 343 deletions(-)
 delete mode 100644 backend-rs/src/routing.rs
 create mode 100644 backend-rs/src/routing/handlers.rs
 create mode 100644 backend-rs/src/routing/middleware.rs
 create mode 100644 backend-rs/src/routing/mod.rs

diff --git a/backend-rs/src/routing.rs b/backend-rs/src/routing.rs
deleted file mode 100644
index acfafee..0000000
--- a/backend-rs/src/routing.rs
+++ /dev/null
@@ -1,343 +0,0 @@
-use std::sync::Arc;
-
-use axum::{extract::Json, http::StatusCode, response::IntoResponse};
-use http::{HeaderValue, Method};
-use jwt::Claims;
-use serde::Serialize;
-use tokio::sync::Mutex;
-use tower_http::{
-    cors::{Any, CorsLayer},
-    trace::{self, TraceLayer},
-};
-
-use crate::{
-    db::{self, Database},
-    env::EnvVars,
-};
-
-pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
-    let state = RouterState {
-        db,
-        env_vars: env_vars.clone(),
-        auth: Arc::new(Mutex::new(None)),
-    };
-
-    axum::Router::new()
-        .route("/unapproved", axum::routing::get(handlers::get_unapproved))
-        .route("/profile", axum::routing::get(handlers::profile))
-        .route_layer(axum::middleware::from_fn_with_state(
-            state.clone(),
-            middleware::verify_jwt_middleware,
-        ))
-        .route("/oauth", axum::routing::post(handlers::oauth))
-        .route("/healthcheck", axum::routing::get(handlers::healthcheck))
-        .route("/search", axum::routing::get(handlers::search))
-        .with_state(state)
-        .layer(
-            TraceLayer::new_for_http()
-                .make_span_with(trace::DefaultMakeSpan::new().level(tracing::Level::INFO))
-                .on_response(trace::DefaultOnResponse::new().level(tracing::Level::INFO)),
-        )
-        .layer(
-            CorsLayer::new()
-                .allow_headers(Any)
-                .allow_methods(vec![Method::GET, Method::POST, Method::OPTIONS])
-                .allow_origin(
-                    env_vars
-                        .cors_allowed_origins
-                        .split(',')
-                        .map(|origin| {
-                            origin
-                                .trim()
-                                .parse::<HeaderValue>()
-                                .expect("CORS Allowed Origins Invalid")
-                        })
-                        .collect::<Vec<HeaderValue>>(),
-                ),
-        )
-}
-
-mod handlers {
-    use std::collections::HashMap;
-
-    use axum::{
-        extract::{Json, Query, State},
-        http::StatusCode,
-    };
-    use color_eyre::eyre::Ok;
-    use serde::{Deserialize, Serialize};
-
-    use crate::{
-        auth,
-        qp::{self, AdminDashboardQP},
-    };
-
-    use super::{AppError, BackendResponse, RouterState};
-
-    type HandlerReturn<T> = Result<(StatusCode, BackendResponse<T>), AppError>;
-
-    /// Healthcheck route. Returns a `Hello World.` message if healthy.
-    pub async fn healthcheck() -> HandlerReturn<()> {
-        Ok(BackendResponse::ok("Hello, World.".into(), ())).map_err(AppError::from)
-    }
-
-    pub async fn get_unapproved(
-        State(state): State<RouterState>,
-    ) -> HandlerReturn<Vec<AdminDashboardQP>> {
-        let papers: Vec<AdminDashboardQP> = state.db.get_unapproved_papers().await?;
-
-        let papers = papers
-            .iter()
-            .map(|paper| paper.clone().with_url(&state.env_vars))
-            .collect::<Result<Vec<qp::AdminDashboardQP>, color_eyre::eyre::Error>>()?;
-
-        Ok(BackendResponse::ok(
-            format!("Successfully fetched {} papers.", papers.len()),
-            papers,
-        ))
-        .map_err(AppError::from)
-    }
-
-    pub async fn search(
-        State(state): State<RouterState>,
-        Query(params): Query<HashMap<String, String>>,
-    ) -> HandlerReturn<Vec<qp::SearchQP>> {
-        let response = if let Some(query) = params.get("query") {
-            let exam: Option<qp::Exam> = if let Some(exam_str) = params.get("exam") {
-                Some(qp::Exam::try_from(exam_str).map_err(AppError::from)?)
-            } else {
-                None
-            };
-
-            let papers = state.db.search_papers(query, exam).await?;
-
-            let papers = papers
-                .iter()
-                .map(|paper| paper.clone().with_url(&state.env_vars))
-                .collect::<Result<Vec<qp::SearchQP>, color_eyre::eyre::Error>>()?;
-
-            Ok(BackendResponse::ok(
-                format!("Successfully fetched {} papers.", papers.len()),
-                papers,
-            ))
-        } else {
-            Ok(BackendResponse::error(
-                "`query` URL parameter is required.".into(),
-                StatusCode::BAD_REQUEST,
-            ))
-        };
-
-        response.map_err(AppError::from)
-    }
-
-    #[derive(Deserialize)]
-    pub struct OAuthReq {
-        code: String,
-    }
-    #[derive(Serialize)]
-    pub struct OAuthRes {
-        token: String,
-    }
-    pub async fn oauth(
-        State(state): State<RouterState>,
-        Json(body): Json<OAuthReq>,
-    ) -> HandlerReturn<OAuthRes> {
-        if let Some(token) = auth::authenticate_user(&body.code, &state.env_vars).await? {
-            Ok(BackendResponse::ok(
-                "Successfully authorized the user.".into(),
-                OAuthRes { token },
-            ))
-        } else {
-            Ok(BackendResponse::error(
-                "Error: User unauthorized.".into(),
-                StatusCode::UNAUTHORIZED,
-            ))
-        }
-        .map_err(AppError::from)
-    }
-
-    #[derive(Serialize)]
-    pub struct ProfileRes {
-        token: String,
-        username: String,
-    }
-    pub async fn profile(State(state): State<RouterState>) -> HandlerReturn<ProfileRes> {
-        let lock = state.auth.lock().await;
-
-        if let Some(auth) = lock.clone() {
-            let username = auth.claims.private.get("username");
-
-            if let Some(username) = username {
-                Ok(BackendResponse::ok(
-                    "Successfully authorized the user.".into(),
-                    ProfileRes {
-                        token: auth.jwt,
-                        username: username.to_string(),
-                    },
-                ))
-            } else {
-                Ok(BackendResponse::error(
-                    "Username not found in claims.".into(),
-                    StatusCode::UNAUTHORIZED,
-                ))
-            }
-        } else {
-            Ok(BackendResponse::error(
-                "Error: User unauthorized.".into(),
-                StatusCode::UNAUTHORIZED,
-            ))
-        }
-        .map_err(AppError::from)
-    }
-}
-
-mod middleware {
-    use axum::{
-        extract::{Request, State},
-        middleware::Next,
-        response::{IntoResponse, Response},
-    };
-    use http::{HeaderMap, StatusCode};
-
-    use crate::auth;
-
-    use super::{AppError, Auth, BackendResponse, RouterState};
-
-    pub async fn verify_jwt_middleware(
-        State(state): State<RouterState>,
-        headers: HeaderMap,
-        request: Request,
-        next: Next,
-    ) -> Result<Response, AppError> {
-        if let Some(auth_header) = headers.get("Authorization") {
-            if let Some(jwt) = auth_header.to_str()?.strip_prefix("Bearer ") {
-                let claims = auth::verify_token(jwt, &state.env_vars).await?;
-
-                if let Some(claims) = claims {
-                    let mut state_jwt = state.auth.lock().await;
-                    *state_jwt = Auth {
-                        jwt: jwt.to_string(),
-                        claims,
-                    }
-                    .into();
-                } else {
-                    return Ok(BackendResponse::<()>::error(
-                        "Authorization token invalid.".into(),
-                        StatusCode::UNAUTHORIZED,
-                    )
-                    .into_response());
-                }
-            } else {
-                return Ok(BackendResponse::<()>::error(
-                    "Authorization header format invalid.".into(),
-                    StatusCode::UNAUTHORIZED,
-                )
-                .into_response());
-            }
-        } else {
-            return Ok(BackendResponse::<()>::error(
-                "Authorization header missing.".into(),
-                StatusCode::UNAUTHORIZED,
-            )
-            .into_response());
-        }
-
-        Ok(next.run(request).await)
-    }
-}
-
-#[derive(Clone)]
-struct Auth {
-    jwt: String,
-    claims: Claims,
-}
-#[derive(Clone)]
-struct RouterState {
-    pub db: db::Database,
-    pub env_vars: EnvVars,
-    pub auth: Arc<Mutex<Option<Auth>>>,
-}
-
-#[derive(Clone, Copy)]
-enum Status {
-    Success,
-    Error,
-}
-
-impl From<Status> for String {
-    fn from(value: Status) -> Self {
-        match value {
-            Status::Success => "success".into(),
-            Status::Error => "error".into(),
-        }
-    }
-}
-
-impl Serialize for Status {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&String::from(*self))
-    }
-}
-
-/// Standard backend response format (serialized as JSON)
-#[derive(serde::Serialize)]
-struct BackendResponse<T: Serialize> {
-    pub status: Status,
-    pub message: String,
-    pub data: Option<T>,
-}
-
-impl<T: serde::Serialize> BackendResponse<T> {
-    pub fn ok(message: String, data: T) -> (StatusCode, Self) {
-        (
-            StatusCode::OK,
-            Self {
-                status: Status::Success,
-                message,
-                data: Some(data),
-            },
-        )
-    }
-
-    pub fn error(message: String, status_code: StatusCode) -> (StatusCode, Self) {
-        (
-            status_code,
-            Self {
-                status: Status::Error,
-                message,
-                data: None,
-            },
-        )
-    }
-}
-
-impl<T: Serialize> IntoResponse for BackendResponse<T> {
-    fn into_response(self) -> axum::response::Response {
-        Json(self).into_response()
-    }
-}
-
-pub(super) struct AppError(color_eyre::eyre::Error);
-impl IntoResponse for AppError {
-    fn into_response(self) -> axum::response::Response {
-        tracing::error!("An error occured: {}", self.0);
-
-        BackendResponse::<()>::error(
-            format!("Internal error: {}", self.0),
-            StatusCode::INTERNAL_SERVER_ERROR,
-        )
-        .into_response()
-    }
-}
-
-impl<E> From<E> for AppError
-where
-    E: Into<color_eyre::eyre::Error>,
-{
-    fn from(err: E) -> Self {
-        Self(err.into())
-    }
-}
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
new file mode 100644
index 0000000..2c260f3
--- /dev/null
+++ b/backend-rs/src/routing/handlers.rs
@@ -0,0 +1,127 @@
+use axum::{extract::Json, http::StatusCode};
+use serde::Serialize;
+
+use std::collections::HashMap;
+
+use axum::extract::{Query, State};
+use serde::Deserialize;
+
+use crate::{
+    auth,
+    qp::{self, AdminDashboardQP},
+};
+
+use super::{AppError, BackendResponse, RouterState};
+
+type HandlerReturn<T> = Result<(StatusCode, BackendResponse<T>), AppError>;
+
+/// Healthcheck route. Returns a `Hello World.` message if healthy.
+pub async fn healthcheck() -> HandlerReturn<()> {
+    Ok(BackendResponse::ok("Hello, World.".into(), ()))
+}
+
+pub async fn get_unapproved(
+    State(state): State<RouterState>,
+) -> HandlerReturn<Vec<AdminDashboardQP>> {
+    let papers: Vec<AdminDashboardQP> = state.db.get_unapproved_papers().await?;
+
+    let papers = papers
+        .iter()
+        .map(|paper| paper.clone().with_url(&state.env_vars))
+        .collect::<Result<Vec<qp::AdminDashboardQP>, color_eyre::eyre::Error>>()?;
+
+    Ok(BackendResponse::ok(
+        format!("Successfully fetched {} papers.", papers.len()),
+        papers,
+    ))
+}
+
+pub async fn search(
+    State(state): State<RouterState>,
+    Query(params): Query<HashMap<String, String>>,
+) -> HandlerReturn<Vec<qp::SearchQP>> {
+    let response = if let Some(query) = params.get("query") {
+        let exam: Option<qp::Exam> = if let Some(exam_str) = params.get("exam") {
+            Some(qp::Exam::try_from(exam_str).map_err(AppError::from)?)
+        } else {
+            None
+        };
+
+        let papers = state.db.search_papers(query, exam).await?;
+
+        let papers = papers
+            .iter()
+            .map(|paper| paper.clone().with_url(&state.env_vars))
+            .collect::<Result<Vec<qp::SearchQP>, color_eyre::eyre::Error>>()?;
+
+        Ok(BackendResponse::ok(
+            format!("Successfully fetched {} papers.", papers.len()),
+            papers,
+        ))
+    } else {
+        Ok(BackendResponse::error(
+            "`query` URL parameter is required.".into(),
+            StatusCode::BAD_REQUEST,
+        ))
+    };
+
+    response
+}
+
+#[derive(Deserialize)]
+pub struct OAuthReq {
+    code: String,
+}
+#[derive(Serialize)]
+pub struct OAuthRes {
+    token: String,
+}
+pub async fn oauth(
+    State(state): State<RouterState>,
+    Json(body): Json<OAuthReq>,
+) -> HandlerReturn<OAuthRes> {
+    if let Some(token) = auth::authenticate_user(&body.code, &state.env_vars).await? {
+        Ok(BackendResponse::ok(
+            "Successfully authorized the user.".into(),
+            OAuthRes { token },
+        ))
+    } else {
+        Ok(BackendResponse::error(
+            "Error: User unauthorized.".into(),
+            StatusCode::UNAUTHORIZED,
+        ))
+    }
+}
+
+#[derive(Serialize)]
+pub struct ProfileRes {
+    token: String,
+    username: String,
+}
+pub async fn profile(State(state): State<RouterState>) -> HandlerReturn<ProfileRes> {
+    let lock = state.auth.lock().await;
+
+    if let Some(auth) = lock.clone() {
+        let username = auth.claims.private.get("username");
+
+        if let Some(username) = username {
+            Ok(BackendResponse::ok(
+                "Successfully authorized the user.".into(),
+                ProfileRes {
+                    token: auth.jwt,
+                    username: username.to_string(),
+                },
+            ))
+        } else {
+            Ok(BackendResponse::error(
+                "Username not found in claims.".into(),
+                StatusCode::UNAUTHORIZED,
+            ))
+        }
+    } else {
+        Ok(BackendResponse::error(
+            "Error: User unauthorized.".into(),
+            StatusCode::UNAUTHORIZED,
+        ))
+    }
+}
diff --git a/backend-rs/src/routing/middleware.rs b/backend-rs/src/routing/middleware.rs
new file mode 100644
index 0000000..942cb05
--- /dev/null
+++ b/backend-rs/src/routing/middleware.rs
@@ -0,0 +1,52 @@
+use axum::{
+    extract::{Request, State},
+    middleware::Next,
+    response::{IntoResponse, Response},
+};
+use http::{HeaderMap, StatusCode};
+
+use crate::auth;
+
+use super::{AppError, Auth, BackendResponse, RouterState};
+
+pub async fn verify_jwt_middleware(
+    State(state): State<RouterState>,
+    headers: HeaderMap,
+    request: Request,
+    next: Next,
+) -> Result<Response, AppError> {
+    if let Some(auth_header) = headers.get("Authorization") {
+        if let Some(jwt) = auth_header.to_str()?.strip_prefix("Bearer ") {
+            let claims = auth::verify_token(jwt, &state.env_vars).await?;
+
+            if let Some(claims) = claims {
+                let mut state_jwt = state.auth.lock().await;
+                *state_jwt = Auth {
+                    jwt: jwt.to_string(),
+                    claims,
+                }
+                .into();
+            } else {
+                return Ok(BackendResponse::<()>::error(
+                    "Authorization token invalid.".into(),
+                    StatusCode::UNAUTHORIZED,
+                )
+                .into_response());
+            }
+        } else {
+            return Ok(BackendResponse::<()>::error(
+                "Authorization header format invalid.".into(),
+                StatusCode::UNAUTHORIZED,
+            )
+            .into_response());
+        }
+    } else {
+        return Ok(BackendResponse::<()>::error(
+            "Authorization header missing.".into(),
+            StatusCode::UNAUTHORIZED,
+        )
+        .into_response());
+    }
+
+    Ok(next.run(request).await)
+}
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
new file mode 100644
index 0000000..c790ea7
--- /dev/null
+++ b/backend-rs/src/routing/mod.rs
@@ -0,0 +1,157 @@
+use std::sync::Arc;
+
+use axum::{extract::Json, http::StatusCode, response::IntoResponse};
+use http::{HeaderValue, Method};
+use jwt::Claims;
+use serde::Serialize;
+use tokio::sync::Mutex;
+use tower_http::{
+    cors::{Any, CorsLayer},
+    trace::{self, TraceLayer},
+};
+
+use crate::{
+    db::{self, Database},
+    env::EnvVars,
+};
+
+mod handlers;
+mod middleware;
+
+pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
+    let state = RouterState {
+        db,
+        env_vars: env_vars.clone(),
+        auth: Arc::new(Mutex::new(None)),
+    };
+
+    axum::Router::new()
+        .route("/unapproved", axum::routing::get(handlers::get_unapproved))
+        .route("/profile", axum::routing::get(handlers::profile))
+        .route_layer(axum::middleware::from_fn_with_state(
+            state.clone(),
+            middleware::verify_jwt_middleware,
+        ))
+        .route("/oauth", axum::routing::post(handlers::oauth))
+        .route("/healthcheck", axum::routing::get(handlers::healthcheck))
+        .route("/search", axum::routing::get(handlers::search))
+        .with_state(state)
+        .layer(
+            TraceLayer::new_for_http()
+                .make_span_with(trace::DefaultMakeSpan::new().level(tracing::Level::INFO))
+                .on_response(trace::DefaultOnResponse::new().level(tracing::Level::INFO)),
+        )
+        .layer(
+            CorsLayer::new()
+                .allow_headers(Any)
+                .allow_methods(vec![Method::GET, Method::POST, Method::OPTIONS])
+                .allow_origin(
+                    env_vars
+                        .cors_allowed_origins
+                        .split(',')
+                        .map(|origin| {
+                            origin
+                                .trim()
+                                .parse::<HeaderValue>()
+                                .expect("CORS Allowed Origins Invalid")
+                        })
+                        .collect::<Vec<HeaderValue>>(),
+                ),
+        )
+}
+
+#[derive(Clone)]
+struct Auth {
+    jwt: String,
+    claims: Claims,
+}
+#[derive(Clone)]
+struct RouterState {
+    pub db: db::Database,
+    pub env_vars: EnvVars,
+    pub auth: Arc<Mutex<Option<Auth>>>,
+}
+
+#[derive(Clone, Copy)]
+enum Status {
+    Success,
+    Error,
+}
+
+impl From<Status> for String {
+    fn from(value: Status) -> Self {
+        match value {
+            Status::Success => "success".into(),
+            Status::Error => "error".into(),
+        }
+    }
+}
+
+impl Serialize for Status {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&String::from(*self))
+    }
+}
+
+/// Standard backend response format (serialized as JSON)
+#[derive(serde::Serialize)]
+struct BackendResponse<T: Serialize> {
+    pub status: Status,
+    pub message: String,
+    pub data: Option<T>,
+}
+
+impl<T: serde::Serialize> BackendResponse<T> {
+    pub fn ok(message: String, data: T) -> (StatusCode, Self) {
+        (
+            StatusCode::OK,
+            Self {
+                status: Status::Success,
+                message,
+                data: Some(data),
+            },
+        )
+    }
+
+    pub fn error(message: String, status_code: StatusCode) -> (StatusCode, Self) {
+        (
+            status_code,
+            Self {
+                status: Status::Error,
+                message,
+                data: None,
+            },
+        )
+    }
+}
+
+impl<T: Serialize> IntoResponse for BackendResponse<T> {
+    fn into_response(self) -> axum::response::Response {
+        Json(self).into_response()
+    }
+}
+
+pub(super) struct AppError(color_eyre::eyre::Error);
+impl IntoResponse for AppError {
+    fn into_response(self) -> axum::response::Response {
+        tracing::error!("An error occured: {}", self.0);
+
+        BackendResponse::<()>::error(
+            format!("Internal error: {}", self.0),
+            StatusCode::INTERNAL_SERVER_ERROR,
+        )
+        .into_response()
+    }
+}
+
+impl<E> From<E> for AppError
+where
+    E: Into<color_eyre::eyre::Error>,
+{
+    fn from(err: E) -> Self {
+        Self(err.into())
+    }
+}

From cc2b493b634d962792eb4b43a63bd4f0aed7403f Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 01:14:37 +0530
Subject: [PATCH 04/33] feat: edit paper details endpoint

---
 backend-rs/src/db.rs                 | 103 +++++++++++++++++++++++++-
 backend-rs/src/env.rs                |  25 ++++++-
 backend-rs/src/qp.rs                 |  10 ++-
 backend-rs/src/routing/handlers.rs   | 107 ++++++++++++++++++++++++---
 backend-rs/src/routing/middleware.rs |  18 +++--
 backend-rs/src/routing/mod.rs        |   4 +-
 6 files changed, 244 insertions(+), 23 deletions(-)

diff --git a/backend-rs/src/db.rs b/backend-rs/src/db.rs
index b467ec4..e21b559 100644
--- a/backend-rs/src/db.rs
+++ b/backend-rs/src/db.rs
@@ -1,10 +1,11 @@
+use color_eyre::eyre::{eyre, ContextCompat};
 use queries::get_qp_search_query;
-use sqlx::{postgres::PgPoolOptions, PgPool};
+use sqlx::{postgres::PgPoolOptions, PgPool, Postgres, Transaction};
 use std::time::Duration;
 
 use crate::{
     env::EnvVars,
-    qp::{self, Exam},
+    qp::{self, Exam, Semester},
 };
 
 #[derive(Clone)]
@@ -12,6 +13,15 @@ pub struct Database {
     connection: PgPool,
 }
 
+pub struct EditDetails {
+    pub course_code: String,
+    pub course_name: String,
+    pub year: i32,
+    pub semester: Semester,
+    pub exam: Exam,
+    pub approve_status: bool,
+}
+
 impl Database {
     pub async fn try_new(env_vars: &EnvVars) -> Result<Self, sqlx::Error> {
         let database_url = format!(
@@ -74,6 +84,76 @@ impl Database {
 
         Ok(paper.into())
     }
+
+    /// Edit's a paper's details.
+    ///
+    /// - If the paper is approved, the filename is also changed and it is moved to `/static_file_storage_location/uploaded_qps_path/approved/`.
+    /// - If the paper is unapproved, the file is not moved again, same goes for library papers.
+    /// - Sets the `approved_by` field to the username if approved.
+    ///
+    /// Returns the database transaction and the new filelink
+    pub async fn edit_paper<'c>(
+        &self,
+        id: i32,
+        edit_details: EditDetails,
+        newly_approved: bool,
+        username: &str,
+        env_vars: &EnvVars,
+    ) -> Result<(Transaction<'c, Postgres>, String), color_eyre::eyre::Error> {
+        let mut tx = self.connection.begin().await?;
+
+        let EditDetails {
+            course_code,
+            course_name,
+            year,
+            semester,
+            exam,
+            approve_status,
+        } = edit_details;
+
+        let semester = String::from(semester);
+        let exam = String::from(exam);
+
+        let query_sql = queries::get_edit_paper_query(newly_approved);
+        let query = sqlx::query(&query_sql)
+            .bind(id)
+            .bind(&course_code)
+            .bind(&course_name)
+            .bind(year)
+            .bind(&semester)
+            .bind(&exam)
+            .bind(approve_status);
+
+        let filelink = env_vars
+            .get_uploaded_paper_slugs()
+            .approved
+            .join(format!(
+                "{}_{}_{}_{}_{}_{}.pdf",
+                id, course_code, course_name, year, semester, exam
+            ))
+            .to_str()
+            .context("Error converting approved papers path to string.")?
+            .to_owned();
+
+        let query = if newly_approved {
+            query.bind(&filelink).bind(username)
+        } else {
+            query
+        };
+
+        let rows_affected = query.execute(&mut *tx).await?.rows_affected();
+
+        if rows_affected != 1 {
+            tx.rollback().await?;
+
+            return Err(eyre!(
+                "An invalid number of rows were changed: {}",
+                rows_affected
+            ));
+        }
+
+        Ok((tx, filelink))
+    }
 }
 
 mod models {
@@ -145,6 +225,25 @@ mod queries {
     /// Get a paper ([`crate::db::models::DBAdminDashboardQP`]) with the given id (first parameter `$1`)
     pub const GET_PAPER_BY_ID: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE id = $1";
 
+    /// Returns a query that updates a paper's details by id ($1) (course_code, course_name, year, semester, exam, approve_status). `filelink` and `approved_by` optionally included if the edit is also used for approval.
+    ///
+    /// Query parameters:
+    /// - $1: `id`
+    /// - $2: `course_code`
+    /// - $3: `course_name`
+    /// - $4: `year`
+    /// - $5: `semester`
+    /// - $6: `exam`
+    /// - $7: `approve_status`
+    /// - $8: `filelink`
+    /// - $9: `approved_by`
+    pub fn get_edit_paper_query(approval: bool) -> String {
+        format!(
+            "UPDATE iqps set course_code=$2, course_name=$3, year=$4, semester=$5, exam=$6, approve_status=$7{} WHERE id=$1 AND is_deleted=false",
+            if approval {", filelink=$8, approved_by=$9"} else {""}
+        )
+    }
+
     /// Gets all unapproved papers ([`crate::db::models::DBAdminDashboardQP`]) from the database
     pub const GET_ALL_UNAPPROVED: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE approve_status = false and is_deleted=false ORDER BY upload_timestamp ASC";
 
diff --git a/backend-rs/src/env.rs b/backend-rs/src/env.rs
index d1871d2..30fbf0d 100644
--- a/backend-rs/src/env.rs
+++ b/backend-rs/src/env.rs
@@ -58,7 +58,7 @@ pub struct EnvVars {
     #[arg(env, default_value = "/srv/static")]
     /// The path where static files are served from
     pub static_file_storage_location: PathBuf,
-    #[arg(env, default_value = "iqps/uploaded")]
+    #[arg(env, default_value = "/iqps/uploaded")]
     /// The path where uploaded papers are stored temporarily, relative to the `static_file_storage_location`
     pub uploaded_qps_path: PathBuf,
 
@@ -73,6 +73,11 @@ pub struct EnvVars {
     pub cors_allowed_origins: String,
 }
 
+pub struct UploadPaths {
+    pub unapproved: PathBuf,
+    pub approved: PathBuf,
+}
+
 impl EnvVars {
     /// Processes the environment variables after reading.
     pub fn process(mut self) -> Result<Self, Box<dyn std::error::Error>> {
@@ -90,4 +95,22 @@ impl EnvVars {
     pub fn get_jwt_key(&self) -> Result<Hmac<Sha256>, InvalidLength> {
         Hmac::new_from_slice(self.jwt_secret.as_bytes())
     }
+
+    /// Gets the paths where (unapproved, approved) uploaded papers are stored
+    pub fn get_uploaded_paper_paths(&self) -> UploadPaths {
+        let slugs = self.get_uploaded_paper_slugs();
+
+        UploadPaths {
+            unapproved: self.static_file_storage_location.join(slugs.unapproved),
+            approved: self.static_file_storage_location.join(slugs.approved),
+        }
+    }
+
+    /// Gets the slugs (relative paths stored in the db) where (unapproved, approved) uploaded papers are stored
+    pub fn get_uploaded_paper_slugs(&self) -> UploadPaths {
+        UploadPaths {
+            unapproved: self.uploaded_qps_path.join("unapproved"),
+            approved: self.uploaded_qps_path.join("approved"),
+        }
+    }
 }
diff --git a/backend-rs/src/qp.rs b/backend-rs/src/qp.rs
index 51a3d4d..fee7c87 100644
--- a/backend-rs/src/qp.rs
+++ b/backend-rs/src/qp.rs
@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use color_eyre::eyre::eyre;
 use duplicate::duplicate_item;
 use serde::Serialize;
@@ -85,11 +87,11 @@ impl From<Exam> for String {
 }
 
 #[duplicate_item(
-    StrSerializeType;
+    ExamSem;
     [ Exam ];
     [ Semester ];
 )]
-impl Serialize for StrSerializeType {
+impl Serialize for ExamSem {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -139,4 +141,8 @@ impl QP {
             ..self
         })
     }
+
+    pub fn get_paper_path(&self, env_vars: &EnvVars) -> PathBuf {
+        env_vars.static_file_storage_location.join(&self.filelink)
+    }
 }
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index 2c260f3..161da6e 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -1,5 +1,6 @@
 use axum::{extract::Json, http::StatusCode};
 use serde::Serialize;
+use tokio::fs;
 
 use std::collections::HashMap;
 
@@ -8,7 +9,8 @@ use serde::Deserialize;
 
 use crate::{
     auth,
-    qp::{self, AdminDashboardQP},
+    db::EditDetails,
+    qp::{self, AdminDashboardQP, Exam, Semester},
 };
 
 use super::{AppError, BackendResponse, RouterState};
@@ -102,25 +104,108 @@ pub async fn profile(State(state): State<RouterState>) -> HandlerReturn<ProfileR
     let lock = state.auth.lock().await;
 
     if let Some(auth) = lock.clone() {
-        let username = auth.claims.private.get("username");
+        Ok(BackendResponse::ok(
+            "Successfully authorized the user.".into(),
+            ProfileRes {
+                token: auth.jwt,
+                username: auth.username,
+            },
+        ))
+    } else {
+        Ok(BackendResponse::error(
+            "Error: User unauthorized.".into(),
+            StatusCode::UNAUTHORIZED,
+        ))
+    }
+}
 
-        if let Some(username) = username {
-            Ok(BackendResponse::ok(
-                "Successfully authorized the user.".into(),
-                ProfileRes {
-                    token: auth.jwt,
-                    username: username.to_string(),
+#[derive(Deserialize)]
+pub struct EditReq {
+    pub id: i32,
+    pub course_code: Option<String>,
+    pub course_name: Option<String>,
+    pub year: Option<i32>,
+    pub semester: Option<String>,
+    pub exam: Option<String>,
+    pub approve_status: Option<bool>,
+}
+/// Paper edit endpoint (for admin dashboard)
+/// Takes a JSON request body. The `id` field is required.
+/// Other optional fields can be set to change that particular value in the paper.
+pub async fn edit(
+    State(state): State<RouterState>,
+    Json(body): Json<EditReq>,
+) -> HandlerReturn<AdminDashboardQP> {
+    let EditReq {
+        id,
+        course_code,
+        course_name,
+        year,
+        semester,
+        exam,
+        approve_status,
+    } = body;
+    let auth = state.auth.lock().await;
+
+    if let Some(auth) = auth.clone() {
+        let current_details = state.db.get_paper_by_id(id).await?;
+        let semester = if let Some(sem_str) = semester {
+            Semester::try_from(&sem_str)?
+        } else {
+            current_details.semester
+        };
+        let exam = if let Some(exam_str) = exam {
+            Exam::try_from(&exam_str)?
+        } else {
+            current_details.exam
+        };
+
+        let newly_approved = !current_details.approve_status && approve_status.unwrap_or(false);
+
+        // Edit the database entry
+        let (tx, filelink) = state
+            .db
+            .edit_paper(
+                id,
+                EditDetails {
+                    course_code: course_code.unwrap_or(current_details.course_code.clone()),
+                    course_name: course_name.unwrap_or(current_details.course_name.clone()),
+                    year: year.unwrap_or(current_details.year),
+                    semester,
+                    exam,
+                    approve_status: approve_status.unwrap_or(current_details.approve_status),
                 },
+                newly_approved,
+                &auth.username,
+                &state.env_vars,
+            )
+            .await?;
+
+        // Copy the actual file
+        let old_filepath = current_details.get_paper_path(&state.env_vars);
+        let new_filepath = state.env_vars.static_file_storage_location.join(filelink);
+
+        if fs::copy(old_filepath, new_filepath).await.is_ok() {
+            // Get the new db entry
+            let new_paper = state.db.get_paper_by_id(id).await?;
+
+            // Commit the transaction
+            tx.commit().await?;
+
+            Ok(BackendResponse::ok(
+                "Successfully updated paper details.".into(),
+                new_paper.with_url(&state.env_vars)?,
             ))
         } else {
+            tx.rollback().await?;
             Ok(BackendResponse::error(
-                "Username not found in claims.".into(),
-                StatusCode::UNAUTHORIZED,
+                "Error copying question paper file.".into(),
+                StatusCode::INTERNAL_SERVER_ERROR,
             ))
         }
     } else {
         Ok(BackendResponse::error(
-            "Error: User unauthorized.".into(),
+            "Error getting authenticated user's username.".into(),
             StatusCode::UNAUTHORIZED,
         ))
     }
diff --git a/backend-rs/src/routing/middleware.rs b/backend-rs/src/routing/middleware.rs
index 942cb05..8aa82b7 100644
--- a/backend-rs/src/routing/middleware.rs
+++ b/backend-rs/src/routing/middleware.rs
@@ -20,12 +20,20 @@ pub async fn verify_jwt_middleware(
             let claims = auth::verify_token(jwt, &state.env_vars).await?;
 
             if let Some(claims) = claims {
-                let mut state_jwt = state.auth.lock().await;
-                *state_jwt = Auth {
-                    jwt: jwt.to_string(),
-                    claims,
+                if let Some(username) = claims.private.get("username") {
+                    let mut state_jwt = state.auth.lock().await;
+                    *state_jwt = Auth {
+                        jwt: jwt.to_string(),
+                        username: username.to_string(),
+                    }
+                    .into();
+                } else {
+                    return Ok(BackendResponse::<()>::error(
+                        "Username not found in the claims.".into(),
+                        StatusCode::UNAUTHORIZED,
+                    )
+                    .into_response());
                 }
-                .into();
             } else {
                 return Ok(BackendResponse::<()>::error(
                     "Authorization token invalid.".into(),
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index c790ea7..8f20c63 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -2,7 +2,6 @@ use std::sync::Arc;
 
 use axum::{extract::Json, http::StatusCode, response::IntoResponse};
 use http::{HeaderValue, Method};
-use jwt::Claims;
 use serde::Serialize;
 use tokio::sync::Mutex;
 use tower_http::{
@@ -28,6 +27,7 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
     axum::Router::new()
         .route("/unapproved", axum::routing::get(handlers::get_unapproved))
         .route("/profile", axum::routing::get(handlers::profile))
+        .route("/edit", axum::routing::get(handlers::edit))
         .route_layer(axum::middleware::from_fn_with_state(
             state.clone(),
             middleware::verify_jwt_middleware,
@@ -63,7 +63,7 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
 #[derive(Clone)]
 struct Auth {
     jwt: String,
-    claims: Claims,
+    username: String,
 }
 #[derive(Clone)]
 struct RouterState {

From 030b42cf3deb0c9ab334b34118e7a067e2a0bb26 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 01:18:52 +0530
Subject: [PATCH 05/33] feat: use the edit endpoint (expect a few more commits
 fixing bugs)

---
 frontend/src/pages/AdminDashboard.tsx |  5 ++---
 frontend/src/types/backend.ts         | 14 +++++++++++---
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/frontend/src/pages/AdminDashboard.tsx b/frontend/src/pages/AdminDashboard.tsx
index 7875dbd..c2173fb 100644
--- a/frontend/src/pages/AdminDashboard.tsx
+++ b/frontend/src/pages/AdminDashboard.tsx
@@ -28,9 +28,8 @@ function AdminDashboard() {
 		// Only approves the paper rn
 		// TODO: Allow unapproving papers as well
 
-		const response = await makeRequest('approve', 'post', {
-			...qp,
-			filelink: new URL(qp.filelink).pathname // TODO: PLEASE DO THIS IN THE BAKCEND AHHHH ITS CALLED FILELINK NOT FILEPATH DED
+		const response = await makeRequest('edit', 'post', {
+			...qp
 		}, auth.jwt);
 
 		if (response.status === "success") {
diff --git a/frontend/src/types/backend.ts b/frontend/src/types/backend.ts
index d63a9ef..ee6ea02 100644
--- a/frontend/src/types/backend.ts
+++ b/frontend/src/types/backend.ts
@@ -46,8 +46,16 @@ export interface IEndpointTypes {
 			description: string;
 		}[]
 	},
-	approve: {
-		request: IAdminDashboardQP,
+	edit: {
+		request: {
+			id: number,
+			course_code?: string,
+			course_name?: string,
+			year?: number,
+			semester?: string,
+			exam?: string,
+			approve_status?: boolean,
+		},
 		response: {
 			id: number;
 		}
@@ -57,7 +65,7 @@ export interface IEndpointTypes {
 			id: number;
 		},
 		response: null;
-	},
+	}
 	profile: {
 		request: null;
 		response: {

From d9221812907e041faebe8f53b65b9aeed0c54a52 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 01:23:43 +0530
Subject: [PATCH 06/33] fix: change get to post (this is not the commit i
 expected)

---
 backend-rs/src/routing/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 8f20c63..832e12e 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -27,7 +27,7 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
     axum::Router::new()
         .route("/unapproved", axum::routing::get(handlers::get_unapproved))
         .route("/profile", axum::routing::get(handlers::profile))
-        .route("/edit", axum::routing::get(handlers::edit))
+        .route("/edit", axum::routing::post(handlers::edit))
         .route_layer(axum::middleware::from_fn_with_state(
             state.clone(),
             middleware::verify_jwt_middleware,

From 481b6cdb0cec7d9541cfca880626553fa7f07fec Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 01:25:32 +0530
Subject: [PATCH 07/33] featfix: did some stuff this is too late and i am
 exhausted

---
 frontend/src/components/Common/PaperEditModal.tsx | 2 +-
 frontend/src/pages/AdminDashboard.tsx             | 6 +-----
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/frontend/src/components/Common/PaperEditModal.tsx b/frontend/src/components/Common/PaperEditModal.tsx
index cc76ba7..202f151 100644
--- a/frontend/src/components/Common/PaperEditModal.tsx
+++ b/frontend/src/components/Common/PaperEditModal.tsx
@@ -245,7 +245,7 @@ function PaperEditModal<T extends IQuestionPaperFile | IAdminDashboardQP>(props:
 				{
 					'approve_status' in data &&
 
-					<FormGroup label="Approval Status (does nothing rn):">
+					<FormGroup label="Approval Status:">
 						<button
 							className={`btn approve-btn ${data.approve_status ? 'approved' : 'unapproved'}`}
 							onClick={(e) => {
diff --git a/frontend/src/pages/AdminDashboard.tsx b/frontend/src/pages/AdminDashboard.tsx
index c2173fb..d4981a4 100644
--- a/frontend/src/pages/AdminDashboard.tsx
+++ b/frontend/src/pages/AdminDashboard.tsx
@@ -25,9 +25,6 @@ function AdminDashboard() {
 		useState<IAdminDashboardQP | null>(null);
 
 	const handlePaperEdit = async (qp: IAdminDashboardQP) => {
-		// Only approves the paper rn
-		// TODO: Allow unapproving papers as well
-
 		const response = await makeRequest('edit', 'post', {
 			...qp
 		}, auth.jwt);
@@ -41,8 +38,7 @@ function AdminDashboard() {
 				const selectedIndex = newPapers.indexOf(selectedQPaper!);
 				if (selectedIndex !== -1) {
 					newPapers[selectedIndex] = {
-						...qp,
-						approve_status: true
+						...qp
 					}
 				}
 

From f95efbaa9f25b5750955740b20db50fbc426554b Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 14:46:02 +0530
Subject: [PATCH 08/33] feat: first commit the previous transaction then get
 the new db entry

---
 backend-rs/src/routing/handlers.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index 161da6e..6b56acb 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -186,12 +186,12 @@ pub async fn edit(
         let new_filepath = state.env_vars.static_file_storage_location.join(filelink);
 
         if fs::copy(old_filepath, new_filepath).await.is_ok() {
-            // Get the new db entry
-            let new_paper = state.db.get_paper_by_id(id).await?;
-
             // Commit the transaction
             tx.commit().await?;
 
+            // Get the new db entry
+            let new_paper = state.db.get_paper_by_id(id).await?;
+
             Ok(BackendResponse::ok(
                 "Successfully updated paper details.".into(),
                 new_paper.with_url(&state.env_vars)?,

From fff7693976f812f8c93a363de0ae81ac6d53857d Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 15:57:36 +0530
Subject: [PATCH 09/33] feat<partial>: upload endpoint

---
 backend-rs/Cargo.lock              |  18 +++++
 backend-rs/Cargo.toml              |   2 +-
 backend-rs/src/env.rs              |   2 +-
 backend-rs/src/routing/handlers.rs | 126 ++++++++++++++++++++++++++++-
 backend-rs/src/routing/mod.rs      |   5 +-
 frontend/src/pages/UploadPage.tsx  |  26 ++++--
 frontend/src/types/backend.ts      |   4 +-
 7 files changed, 171 insertions(+), 12 deletions(-)

diff --git a/backend-rs/Cargo.lock b/backend-rs/Cargo.lock
index 4bf4b99..3b04350 100644
--- a/backend-rs/Cargo.lock
+++ b/backend-rs/Cargo.lock
@@ -150,6 +150,7 @@ dependencies = [
  "matchit",
  "memchr",
  "mime",
+ "multer",
  "percent-encoding",
  "pin-project-lite",
  "rustversion",
@@ -1141,6 +1142,23 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "multer"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
+dependencies = [
+ "bytes",
+ "encoding_rs",
+ "futures-util",
+ "http",
+ "httparse",
+ "memchr",
+ "mime",
+ "spin",
+ "version_check",
+]
+
 [[package]]
 name = "native-tls"
 version = "0.2.12"
diff --git a/backend-rs/Cargo.toml b/backend-rs/Cargo.toml
index 0058b7f..c85380a 100644
--- a/backend-rs/Cargo.toml
+++ b/backend-rs/Cargo.toml
@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-axum = "0.7.7"
+axum = { version = "0.7.7", features = ["multipart"] }
 chrono = "0.4.38"
 clap = { version = "4.5.20", features = ["derive", "env"] }
 color-eyre = "0.6.3"
diff --git a/backend-rs/src/env.rs b/backend-rs/src/env.rs
index 30fbf0d..7d18ecb 100644
--- a/backend-rs/src/env.rs
+++ b/backend-rs/src/env.rs
@@ -46,7 +46,7 @@ pub struct EnvVars {
     // Other configs
     #[arg(env, default_value = "10")]
     /// Maximum number of papers that can be uploaded at a time
-    pub max_upload_limit: i32,
+    pub max_upload_limit: usize,
     #[arg(env, default_value = "./log/application.log")]
     /// Location where logs are stored
     pub log_location: PathBuf,
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index 6b56acb..dea6400 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -1,4 +1,9 @@
-use axum::{extract::Json, http::StatusCode};
+use axum::{
+    body::Bytes,
+    extract::{Json, Multipart},
+    http::StatusCode,
+};
+use http::HeaderMap;
 use serde::Serialize;
 use tokio::fs;
 
@@ -13,7 +18,7 @@ use crate::{
     qp::{self, AdminDashboardQP, Exam, Semester},
 };
 
-use super::{AppError, BackendResponse, RouterState};
+use super::{AppError, BackendResponse, RouterState, Status};
 
 type HandlerReturn<T> = Result<(StatusCode, BackendResponse<T>), AppError>;
 
@@ -210,3 +215,120 @@ pub async fn edit(
         ))
     }
 }
+
+#[derive(Deserialize)]
+pub struct FileDetails {
+    course_code: String,
+    course_name: String,
+    year: i32,
+    exam: String,
+    semester: String,
+    filename: String,
+}
+
+/// 10 MiB file size limit
+const FILE_SIZE_LIMIT: usize = 10 << 20;
+#[derive(Serialize)]
+pub struct UploadStatus {
+    filename: String,
+    status: Status,
+    message: String,
+}
+pub async fn upload(
+    State(state): State<RouterState>,
+    mut multipart: Multipart,
+) -> HandlerReturn<Vec<UploadStatus>> {
+    let mut files = Vec::<(HeaderMap, Bytes)>::new();
+    let mut file_details: String = "".into();
+
+    while let Some(field) = multipart.next_field().await.unwrap() {
+        let name = field.name().unwrap().to_string();
+
+        if name == "files" {
+            files.push((field.headers().clone(), field.bytes().await?));
+        } else if name == "file_details" {
+            if file_details.is_empty() {
+                file_details = field.text().await?;
+            } else {
+                return Ok(BackendResponse::error(
+                    "Error: Multiple `file_details` fields found.".into(),
+                    StatusCode::BAD_REQUEST,
+                ));
+            }
+        }
+    }
+
+    let files = files;
+    let file_details: Vec<FileDetails> = serde_json::from_str(&file_details)?;
+
+    if files.len() > state.env_vars.max_upload_limit {
+        return Ok(BackendResponse::error(
+            format!(
+                "Only upto {} files can be uploaded. Found {}.",
+                state.env_vars.max_upload_limit,
+                files.len()
+            ),
+            StatusCode::BAD_REQUEST,
+        ));
+    }
+
+    if files.len() != file_details.len() {
+        return Ok(BackendResponse::error(
+            "Error: Number of files and file details array length do not match.".into(),
+            StatusCode::BAD_REQUEST,
+        ));
+    }
+
+    let upload_statuses: Vec<UploadStatus> = files
+        .iter()
+        .zip(file_details.iter())
+        .map(|((file_headers, file_data), details)| {
+            let FileDetails {
+                course_code,
+                course_name,
+                year,
+                exam,
+                semester,
+                filename,
+            } = details;
+
+            if file_data.len() > FILE_SIZE_LIMIT {
+                return UploadStatus {
+                    filename: filename.to_owned(),
+                    status: Status::Error,
+                    message: format!(
+                        "File size too big. Only files upto {} MiB are allowed.",
+                        FILE_SIZE_LIMIT >> 20
+                    ),
+                };
+            }
+
+            if let Some(content_type) =  file_headers.get("content-type") {
+                if content_type != "application/pdf" {
+                    return UploadStatus {
+                        filename: filename.to_owned(),
+                        status: Status::Error,
+                        message: "Only PDFs are supported.".into()
+                    };
+                }
+            } else {
+                return UploadStatus {
+                    filename: filename.to_owned(),
+                    status: Status::Error,
+                    message: "`content-type` header not found. File type could not be determined.".into()
+                };
+            }
+
+            UploadStatus {
+                filename: "()".into(),
+                status: Status::Error,
+                message: "()".into(),
+            }
+        })
+        .collect::<Vec<UploadStatus>>();
+
+    Ok(BackendResponse::ok(
+        format!("Successfully processed {} files", upload_statuses.len()),
+        upload_statuses,
+    ))
+}
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 832e12e..e30ac11 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use axum::{extract::Json, http::StatusCode, response::IntoResponse};
+use axum::{extract::{DefaultBodyLimit, Json}, http::StatusCode, response::IntoResponse};
 use http::{HeaderValue, Method};
 use serde::Serialize;
 use tokio::sync::Mutex;
@@ -35,6 +35,9 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
         .route("/oauth", axum::routing::post(handlers::oauth))
         .route("/healthcheck", axum::routing::get(handlers::healthcheck))
         .route("/search", axum::routing::get(handlers::search))
+        .layer(DefaultBodyLimit::max(2 << 20)) // Default limit of 2 MiB
+        .route("/upload", axum::routing::post(handlers::upload))
+        .layer(DefaultBodyLimit::max(50 << 20)) // 50 MiB limit for upload endpoint
         .with_state(state)
         .layer(
             TraceLayer::new_for_http()
diff --git a/frontend/src/pages/UploadPage.tsx b/frontend/src/pages/UploadPage.tsx
index 30838b4..8e23c54 100644
--- a/frontend/src/pages/UploadPage.tsx
+++ b/frontend/src/pages/UploadPage.tsx
@@ -37,6 +37,15 @@ export default function UploadPage() {
             try {
                 const formData = new FormData();
                 const numPapers = qPapers.length;
+                const file_details: {
+                    course_code: string,
+                    course_name: string,
+                    year: number,
+                    exam: string,
+                    semester: string,
+                    filename: string,
+                }[] = [];
+
                 for (const qp of qPapers) {
                     const {
                         file,
@@ -49,11 +58,18 @@ export default function UploadPage() {
                     } = await sanitizeQP(qp);
 
                     formData.append("files", file, file_name);
-                    formData.append(
-                        file_name,
-                        `${course_code}_${course_name}_${year}_${exam}_${semester}`
-                    );
+
+                    file_details.push({
+                        course_code,
+                        course_name,
+                        year,
+                        exam,
+                        semester,
+                        filename: file_name
+                    })
                 }
+                formData.set("file_details", JSON.stringify(file_details));
+
                 toast(
                     `Uploading ${numPapers} file${numPapers > 1 ? "s" : ""}.`
                 );
@@ -71,7 +87,7 @@ export default function UploadPage() {
                             );
                         } else {
                             toast.error(
-                                `Failed to upload file ${result.filename}: ${result.description}`
+                                `Failed to upload file ${result.filename}: ${result.message}`
                             );
                         }
                     }
diff --git a/frontend/src/types/backend.ts b/frontend/src/types/backend.ts
index ee6ea02..3f3c09e 100644
--- a/frontend/src/types/backend.ts
+++ b/frontend/src/types/backend.ts
@@ -42,8 +42,8 @@ export interface IEndpointTypes {
 		request: FormData,
 		response: {
 			filename: string;
-			status: string;
-			description: string;
+			status: "success" | "error";
+			message: string;
 		}[]
 	},
 	edit: {

From 1e62a4757c1894dca5706fee394c5bc021c14bf8 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 16:21:48 +0530
Subject: [PATCH 10/33] feat: added the delete endpoint

---
 backend-rs/src/db.rs               | 28 ++++++++++++++++++++++++++++
 backend-rs/src/routing/handlers.rs | 30 +++++++++++++++++++++++++++---
 backend-rs/src/routing/mod.rs      |  1 +
 3 files changed, 56 insertions(+), 3 deletions(-)

diff --git a/backend-rs/src/db.rs b/backend-rs/src/db.rs
index e21b559..f0ae9d3 100644
--- a/backend-rs/src/db.rs
+++ b/backend-rs/src/db.rs
@@ -154,6 +154,32 @@ impl Database {
 
         Ok((tx, filelink))
     }
+
+    /// Adds a new upload paper's details to the database. Sets the `from_library` field to false.
+    ///
+    /// Returns the database transaction and the id of the uploaded paper
+    // pub async fn add_uploaded_paper<'c>(
+    //     &self,
+    //     file_details:
+    // ) -> Result<(Transaction<'c, Postgres>, i32), color_eyre::eyre::Error> {
+    // }
+
+    /// Sets the `is_deleted` field to true and `approve_status` to false.
+    ///
+    /// Returns a boolean that represents whether a db entry was affected or not. If more than one entry was affected, an error will be thrown and the transaction will be rolled back.
+    pub async fn soft_delete(&self, id: i32) -> Result<bool, color_eyre::eyre::Error> {
+        let mut tx = self.connection.begin().await?;
+
+        let rows_affected = sqlx::query(queries::SOFT_DELETE_BY_ID).bind(id).execute(&mut *tx).await?.rows_affected();
+
+        if rows_affected > 1 {
+            tx.rollback().await?;
+            Err(eyre!("Error: {} (> 1) papers were deleted. Rolling back.", rows_affected))
+        } else {
+            tx.commit().await?;
+            Ok(rows_affected == 1)
+        }
+    }
 }
 
 mod models {
@@ -222,6 +248,8 @@ mod models {
 }
 
 mod queries {
+    pub const SOFT_DELETE_BY_ID: &str = "UPDATE iqps SET approve_status=false, is_deleted = true where id=$1";
+
     /// Get a paper ([`crate::db::models::DBAdminDashboardQP`]) with the given id (first parameter `$1`)
     pub const GET_PAPER_BY_ID: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE id = $1";
 
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index dea6400..2b6cc75 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -303,19 +303,20 @@ pub async fn upload(
                 };
             }
 
-            if let Some(content_type) =  file_headers.get("content-type") {
+            if let Some(content_type) = file_headers.get("content-type") {
                 if content_type != "application/pdf" {
                     return UploadStatus {
                         filename: filename.to_owned(),
                         status: Status::Error,
-                        message: "Only PDFs are supported.".into()
+                        message: "Only PDFs are supported.".into(),
                     };
                 }
             } else {
                 return UploadStatus {
                     filename: filename.to_owned(),
                     status: Status::Error,
-                    message: "`content-type` header not found. File type could not be determined.".into()
+                    message: "`content-type` header not found. File type could not be determined."
+                        .into(),
                 };
             }
 
@@ -332,3 +333,26 @@ pub async fn upload(
         upload_statuses,
     ))
 }
+
+#[derive(Deserialize)]
+pub struct DeleteReq {
+    id: i32,
+}
+pub async fn delete(
+    State(state): State<RouterState>,
+    Json(body): Json<DeleteReq>,
+) -> HandlerReturn<()> {
+    let paper_deleted = state.db.soft_delete(body.id).await?;
+
+    if paper_deleted {
+        Ok(BackendResponse::ok(
+            "Succesfully deleted the paper.".into(),
+            (),
+        ))
+    } else {
+        Ok(BackendResponse::error(
+            "No paper was changed. Either the paper does not exist or is already deleted.".into(),
+            StatusCode::BAD_REQUEST,
+        ))
+    }
+}
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index e30ac11..af8e24f 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -28,6 +28,7 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
         .route("/unapproved", axum::routing::get(handlers::get_unapproved))
         .route("/profile", axum::routing::get(handlers::profile))
         .route("/edit", axum::routing::post(handlers::edit))
+        .route("/delete", axum::routing::post(handlers::delete))
         .route_layer(axum::middleware::from_fn_with_state(
             state.clone(),
             middleware::verify_jwt_middleware,

From c970c3537d946ff7c3bb0eda3102e2da679223c2 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 16:25:42 +0530
Subject: [PATCH 11/33] fix: only delete uploaded papers

---
 backend-rs/src/db.rs               | 5 +++--
 backend-rs/src/routing/handlers.rs | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/backend-rs/src/db.rs b/backend-rs/src/db.rs
index f0ae9d3..213c409 100644
--- a/backend-rs/src/db.rs
+++ b/backend-rs/src/db.rs
@@ -164,7 +164,7 @@ impl Database {
     // ) -> Result<(Transaction<'c, Postgres>, i32), color_eyre::eyre::Error> {
     // }
 
-    /// Sets the `is_deleted` field to true and `approve_status` to false.
+    /// Sets the `is_deleted` field to true and `approve_status` to false. Only deletes uploaded papers.
     ///
     /// Returns a boolean that represents whether a db entry was affected or not. If more than one entry was affected, an error will be thrown and the transaction will be rolled back.
     pub async fn soft_delete(&self, id: i32) -> Result<bool, color_eyre::eyre::Error> {
@@ -248,7 +248,8 @@ mod models {
 }
 
 mod queries {
-    pub const SOFT_DELETE_BY_ID: &str = "UPDATE iqps SET approve_status=false, is_deleted = true where id=$1";
+    /// Soft deletes a paper (sets `approve_status` to false and `is_deleted` to true) of an uploaded paper.
+    pub const SOFT_DELETE_BY_ID: &str = "UPDATE iqps SET approve_status=false, is_deleted = true WHERE id=$1 AND from_library = false";
 
     /// Get a paper ([`crate::db::models::DBAdminDashboardQP`]) with the given id (first parameter `$1`)
     pub const GET_PAPER_BY_ID: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE id = $1";
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index 2b6cc75..db1226a 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -351,7 +351,7 @@ pub async fn delete(
         ))
     } else {
         Ok(BackendResponse::error(
-            "No paper was changed. Either the paper does not exist or is already deleted.".into(),
+            "No paper was changed. Either the paper does not exist, is a library paper (cannot be deleted), or is already deleted.".into(),
             StatusCode::BAD_REQUEST,
         ))
     }

From b08343717ce2d5b7939d486e8c394857540dee7a Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 22:20:37 +0530
Subject: [PATCH 12/33] feat: similar papers endpoint

---
 backend-rs/src/db.rs               | 340 -----------------------------
 backend-rs/src/db/mod.rs           | 223 +++++++++++++++++++
 backend-rs/src/db/models.rs        |  62 ++++++
 backend-rs/src/db/queries.rs       | 143 ++++++++++++
 backend-rs/src/routing/handlers.rs |  27 +++
 backend-rs/src/routing/mod.rs      |   1 +
 6 files changed, 456 insertions(+), 340 deletions(-)
 delete mode 100644 backend-rs/src/db.rs
 create mode 100644 backend-rs/src/db/mod.rs
 create mode 100644 backend-rs/src/db/models.rs
 create mode 100644 backend-rs/src/db/queries.rs

diff --git a/backend-rs/src/db.rs b/backend-rs/src/db.rs
deleted file mode 100644
index 213c409..0000000
--- a/backend-rs/src/db.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-use color_eyre::eyre::{eyre, ContextCompat};
-use queries::get_qp_search_query;
-use sqlx::{postgres::PgPoolOptions, PgPool, Postgres, Transaction};
-use std::time::Duration;
-
-use crate::{
-    env::EnvVars,
-    qp::{self, Exam, Semester},
-};
-
-#[derive(Clone)]
-pub struct Database {
-    connection: PgPool,
-}
-
-pub struct EditDetails {
-    pub course_code: String,
-    pub course_name: String,
-    pub year: i32,
-    pub semester: Semester,
-    pub exam: Exam,
-    pub approve_status: bool,
-}
-
-impl Database {
-    pub async fn try_new(env_vars: &EnvVars) -> Result<Self, sqlx::Error> {
-        let database_url = format!(
-            "postgres://{}:{}@{}:{}/{}",
-            env_vars.db_user,
-            env_vars.db_password,
-            env_vars.db_host,
-            env_vars.db_port,
-            env_vars.db_name
-        );
-
-        let conn_pool = PgPoolOptions::new()
-            .max_connections(5)
-            .acquire_timeout(Duration::from_secs(3))
-            .connect(&database_url)
-            .await?;
-
-        Ok(Self {
-            connection: conn_pool,
-        })
-    }
-
-    pub async fn get_unapproved_papers(&self) -> Result<Vec<qp::AdminDashboardQP>, sqlx::Error> {
-        let papers: Vec<models::DBAdminDashboardQP> = sqlx::query_as(queries::GET_ALL_UNAPPROVED)
-            .fetch_all(&self.connection)
-            .await?;
-
-        Ok(papers
-            .iter()
-            .map(|qp| qp::AdminDashboardQP::from(qp.clone()))
-            .collect())
-    }
-
-    pub async fn search_papers(
-        &self,
-        query: &String,
-        exam: Option<Exam>,
-    ) -> Result<Vec<qp::SearchQP>, sqlx::Error> {
-        let query_sql = get_qp_search_query(exam.is_some());
-        let query = sqlx::query_as(&query_sql).bind(query);
-
-        let query = if let Some(exam) = exam {
-            query.bind(String::from(exam))
-        } else {
-            query
-        };
-
-        let papers: Vec<models::DBSearchQP> = query.fetch_all(&self.connection).await?;
-
-        Ok(papers
-            .iter()
-            .map(|qp| qp::SearchQP::from(qp.clone()))
-            .collect())
-    }
-
-    pub async fn get_paper_by_id(&self, id: i32) -> Result<qp::AdminDashboardQP, sqlx::Error> {
-        let query = sqlx::query_as(queries::GET_PAPER_BY_ID).bind(id);
-
-        let paper: models::DBAdminDashboardQP = query.fetch_one(&self.connection).await?;
-
-        Ok(paper.into())
-    }
-
-    /// Edit's a paper's details.
-    ///
-    /// - If the paper is approved, the filename is also changed and it is moved to `/static_file_storage_location/uploaded_qps_path/approved/`.
-    /// - If the paper is unapproved, the file is not moved again, same goes for library papers.
-    /// - Sets the `approved_by` field to the username if approved.
-    ///
-    /// Returns the database transaction and the new filelink
-    pub async fn edit_paper<'c>(
-        &self,
-        id: i32,
-        edit_details: EditDetails,
-        newly_approved: bool,
-        username: &str,
-        env_vars: &EnvVars,
-    ) -> Result<(Transaction<'c, Postgres>, String), color_eyre::eyre::Error> {
-        let mut tx = self.connection.begin().await?;
-
-        let EditDetails {
-            course_code,
-            course_name,
-            year,
-            semester,
-            exam,
-            approve_status,
-        } = edit_details;
-
-        let semester = String::from(semester);
-        let exam = String::from(exam);
-
-        let query_sql = queries::get_edit_paper_query(newly_approved);
-        let query = sqlx::query(&query_sql)
-            .bind(id)
-            .bind(&course_code)
-            .bind(&course_name)
-            .bind(year)
-            .bind(&semester)
-            .bind(&exam)
-            .bind(approve_status);
-
-        let filelink = env_vars
-            .get_uploaded_paper_slugs()
-            .approved
-            .join(format!(
-                "{}_{}_{}_{}_{}_{}.pdf",
-                id, course_code, course_name, year, semester, exam
-            ))
-            .to_str()
-            .context("Error converting approved papers path to string.")?
-            .to_owned();
-
-        let query = if newly_approved {
-            query.bind(&filelink).bind(username)
-        } else {
-            query
-        };
-
-        let rows_affected = query.execute(&mut *tx).await?.rows_affected();
-
-        if rows_affected != 1 {
-            tx.rollback().await?;
-
-            return Err(eyre!(
-                "An invalid number of rows were changed: {}",
-                rows_affected
-            ));
-        }
-
-        Ok((tx, filelink))
-    }
-
-    /// Adds a new upload paper's details to the database. Sets the `from_library` field to false.
-    ///
-    /// Returns the database transaction and the id of the uploaded paper
-    // pub async fn add_uploaded_paper<'c>(
-    //     &self,
-    //     file_details:
-    // ) -> Result<(Transaction<'c, Postgres>, i32), color_eyre::eyre::Error> {
-    // }
-
-    /// Sets the `is_deleted` field to true and `approve_status` to false. Only deletes uploaded papers.
-    ///
-    /// Returns a boolean that represents whether a db entry was affected or not. If more than one entry was affected, an error will be thrown and the transaction will be rolled back.
-    pub async fn soft_delete(&self, id: i32) -> Result<bool, color_eyre::eyre::Error> {
-        let mut tx = self.connection.begin().await?;
-
-        let rows_affected = sqlx::query(queries::SOFT_DELETE_BY_ID).bind(id).execute(&mut *tx).await?.rows_affected();
-
-        if rows_affected > 1 {
-            tx.rollback().await?;
-            Err(eyre!("Error: {} (> 1) papers were deleted. Rolling back.", rows_affected))
-        } else {
-            tx.commit().await?;
-            Ok(rows_affected == 1)
-        }
-    }
-}
-
-mod models {
-    use crate::qp::Semester;
-
-    use super::qp;
-    use sqlx::{prelude::FromRow, types::chrono};
-
-    #[derive(FromRow, Clone)]
-    pub struct DBSearchQP {
-        id: i32,
-        filelink: String,
-        from_library: bool,
-        course_code: String,
-        course_name: String,
-        year: i32,
-        semester: String,
-        exam: String,
-    }
-
-    #[derive(FromRow, Clone)]
-    pub struct DBAdminDashboardQP {
-        id: i32,
-        filelink: String,
-        from_library: bool,
-        course_code: String,
-        course_name: String,
-        year: i32,
-        semester: String,
-        exam: String,
-        upload_timestamp: chrono::NaiveDateTime,
-        approve_status: bool,
-    }
-
-    impl From<DBAdminDashboardQP> for qp::AdminDashboardQP {
-        fn from(value: DBAdminDashboardQP) -> Self {
-            Self {
-                id: value.id,
-                filelink: value.filelink,
-                from_library: value.from_library,
-                course_code: value.course_code,
-                course_name: value.course_name,
-                year: value.year,
-                semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
-                exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
-                upload_timestamp: value.upload_timestamp.to_string(),
-                approve_status: value.approve_status,
-            }
-        }
-    }
-
-    impl From<DBSearchQP> for qp::SearchQP {
-        fn from(value: DBSearchQP) -> Self {
-            Self {
-                id: value.id,
-                filelink: value.filelink,
-                from_library: value.from_library,
-                course_code: value.course_code,
-                course_name: value.course_name,
-                year: value.year,
-                semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
-                exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
-            }
-        }
-    }
-}
-
-mod queries {
-    /// Soft deletes a paper (sets `approve_status` to false and `is_deleted` to true) of an uploaded paper.
-    pub const SOFT_DELETE_BY_ID: &str = "UPDATE iqps SET approve_status=false, is_deleted = true WHERE id=$1 AND from_library = false";
-
-    /// Get a paper ([`crate::db::models::DBAdminDashboardQP`]) with the given id (first parameter `$1`)
-    pub const GET_PAPER_BY_ID: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE id = $1";
-
-    /// Returns a query that updates a paper's details by id ($1) (course_code, course_name, year, semester, exam, approve_status). `filelink` and `approved_by` optionally included if the edit is also used for approval.
-    ///
-    /// Query parameters:
-    /// - $1: `id`
-    /// - $2: `course_code`
-    /// - $3: `course_name`
-    /// - $4: `year`
-    /// - $5: `semester`
-    /// - $6: `exam`
-    /// - $7: `approve_status`
-    /// - $8: `filelink`
-    /// - $9: `approved_by`
-    pub fn get_edit_paper_query(approval: bool) -> String {
-        format!(
-            "UPDATE iqps set course_code=$2, course_name=$3, year=$4, semester=$5, exam=$6, approve_status=$7{} WHERE id=$1 AND is_deleted=false",
-            if approval {", filelink=$8, approved_by=$9"} else {""}
-        )
-    }
-
-    /// Gets all unapproved papers ([`crate::db::models::DBAdminDashboardQP`]) from the database
-    pub const GET_ALL_UNAPPROVED: &str = "SELECT id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status FROM iqps WHERE approve_status = false and is_deleted=false ORDER BY upload_timestamp ASC";
-
-    /// Searches for papers using the given query_text (parameter `$1`). This is total voodoo by Rajiv Harlalka. The second parameter can be used to filter by exam.
-    /// // TODO: @Rajiv please update this documentation to explain the voodoo.
-    const QP_SEARCH: &str = "
-with fuzzy as (
-    select id,
-           similarity(course_code || ' ' || course_name, $1) as sim_score,
-           row_number() over (order by similarity(course_code || ' ' || course_name, $1) desc) as rank_ix
-    from iqps
-    where (course_code || ' ' || course_name) %>> $1 AND approve_status = true
-    order by rank_ix
-    limit 30
-),
-full_text as (
-  select
-    id,
-    ts_rank_cd(fts_course_details, websearch_to_tsquery($1)) as rank_score,
-    row_number() over(order by ts_rank_cd(fts_course_details , websearch_to_tsquery($1)) desc) as rank_ix
-  from
-    iqps
-  where
-    fts_course_details @@ websearch_to_tsquery($1)
-    AND approve_status = true
-  order by rank_ix
-  limit 30
-),
-partial_search as (
-  select id,
-    ts_rank_cd(fts_course_details , to_tsquery('simple', websearch_to_tsquery('simple', $1)::text || ':*' )) as rank_score,
-    row_number() over(order by ts_rank_cd(fts_course_details , to_tsquery('simple', websearch_to_tsquery('simple', $1)::text || ':*' )) desc) as rank_ix
-  from iqps where
-      fts_course_details @@ to_tsquery(
-        'simple',
-        websearch_to_tsquery('simple', $1)::text || ':*'
-      )
-      AND approve_status = true
-  limit 30
-),  result as (
-  select
-  iqps.id,iqps.course_code, iqps.course_name, iqps.year, iqps.exam, iqps.filelink, iqps.from_library, iqps.upload_timestamp, iqps.approve_status, iqps.semester
-from
-  fuzzy
-  full outer join full_text on fuzzy.id = full_text.id
-  full outer join partial_search on coalesce(fuzzy.id, full_text.id) = partial_search.id
-  join iqps on coalesce(fuzzy.id, full_text.id, partial_search.id) = iqps.id
-order by
-  coalesce(1.0 / (50 + fuzzy.rank_ix), 0.0) * 1 +
-  coalesce(1.0 / (50 + full_text.rank_ix), 0.0) * 1 +
-  coalesce(1.0 / (50 + partial_search.rank_ix), 0.0) * 1
-  desc
-)
-  select * from result";
-
-    pub fn get_qp_search_query(exam: bool) -> String {
-        let mut query = QP_SEARCH.to_owned();
-
-        if exam {
-            query.push_str(" where (exam = $2 or exam = '')");
-        }
-
-        query
-    }
-}
diff --git a/backend-rs/src/db/mod.rs b/backend-rs/src/db/mod.rs
new file mode 100644
index 0000000..73300b2
--- /dev/null
+++ b/backend-rs/src/db/mod.rs
@@ -0,0 +1,223 @@
+use color_eyre::eyre::{eyre, ContextCompat};
+use sqlx::{postgres::PgPoolOptions, PgPool, Postgres, Transaction};
+use std::time::Duration;
+
+use crate::{
+    env::EnvVars,
+    qp::{self, AdminDashboardQP, Exam, Semester},
+};
+
+mod models;
+mod queries;
+
+#[derive(Clone)]
+pub struct Database {
+    connection: PgPool,
+}
+
+pub struct EditDetails {
+    pub course_code: String,
+    pub course_name: String,
+    pub year: i32,
+    pub semester: Semester,
+    pub exam: Exam,
+    pub approve_status: bool,
+}
+
+impl Database {
+    pub async fn try_new(env_vars: &EnvVars) -> Result<Self, sqlx::Error> {
+        let database_url = format!(
+            "postgres://{}:{}@{}:{}/{}",
+            env_vars.db_user,
+            env_vars.db_password,
+            env_vars.db_host,
+            env_vars.db_port,
+            env_vars.db_name
+        );
+
+        let conn_pool = PgPoolOptions::new()
+            .max_connections(5)
+            .acquire_timeout(Duration::from_secs(3))
+            .connect(&database_url)
+            .await?;
+
+        Ok(Self {
+            connection: conn_pool,
+        })
+    }
+
+    pub async fn get_unapproved_papers(&self) -> Result<Vec<qp::AdminDashboardQP>, sqlx::Error> {
+        let query_sql = queries::get_all_unapproved_query();
+        let papers: Vec<models::DBAdminDashboardQP> = sqlx::query_as(&query_sql)
+            .fetch_all(&self.connection)
+            .await?;
+
+        Ok(papers
+            .iter()
+            .map(|qp| qp::AdminDashboardQP::from(qp.clone()))
+            .collect())
+    }
+
+    pub async fn search_papers(
+        &self,
+        query: &String,
+        exam: Option<Exam>,
+    ) -> Result<Vec<qp::SearchQP>, sqlx::Error> {
+        let query_sql = queries::get_qp_search_query(exam.is_some());
+        let query = sqlx::query_as(&query_sql).bind(query);
+
+        let query = if let Some(exam) = exam {
+            query.bind(String::from(exam))
+        } else {
+            query
+        };
+
+        let papers: Vec<models::DBSearchQP> = query.fetch_all(&self.connection).await?;
+
+        Ok(papers
+            .iter()
+            .map(|qp| qp::SearchQP::from(qp.clone()))
+            .collect())
+    }
+
+    pub async fn get_paper_by_id(&self, id: i32) -> Result<qp::AdminDashboardQP, sqlx::Error> {
+        let query_sql = queries::get_get_paper_by_id_query();
+        let query = sqlx::query_as(&query_sql).bind(id);
+
+        let paper: models::DBAdminDashboardQP = query.fetch_one(&self.connection).await?;
+
+        Ok(paper.into())
+    }
+
+    /// Edit's a paper's details.
+    ///
+    /// - If the paper is approved, the filename is also changed and it is moved to `/static_file_storage_location/uploaded_qps_path/approved/`.
+    /// - If the paper is unapproved, the file is not moved again, same goes for library papers.
+    /// - Sets the `approved_by` field to the username if approved.
+    ///
+    /// Returns the database transaction and the new filelink
+    pub async fn edit_paper<'c>(
+        &self,
+        id: i32,
+        edit_details: EditDetails,
+        newly_approved: bool,
+        username: &str,
+        env_vars: &EnvVars,
+    ) -> Result<(Transaction<'c, Postgres>, String), color_eyre::eyre::Error> {
+        let mut tx = self.connection.begin().await?;
+
+        let EditDetails {
+            course_code,
+            course_name,
+            year,
+            semester,
+            exam,
+            approve_status,
+        } = edit_details;
+
+        let semester = String::from(semester);
+        let exam = String::from(exam);
+
+        let query_sql = queries::get_edit_paper_query(newly_approved);
+        let query = sqlx::query(&query_sql)
+            .bind(id)
+            .bind(&course_code)
+            .bind(&course_name)
+            .bind(year)
+            .bind(&semester)
+            .bind(&exam)
+            .bind(approve_status);
+
+        let filelink = env_vars
+            .get_uploaded_paper_slugs()
+            .approved
+            .join(format!(
+                "{}_{}_{}_{}_{}_{}.pdf",
+                id, course_code, course_name, year, semester, exam
+            ))
+            .to_str()
+            .context("Error converting approved papers path to string.")?
+            .to_owned();
+
+        let query = if newly_approved {
+            query.bind(&filelink).bind(username)
+        } else {
+            query
+        };
+
+        let rows_affected = query.execute(&mut *tx).await?.rows_affected();
+
+        if rows_affected != 1 {
+            tx.rollback().await?;
+
+            return Err(eyre!(
+                "An invalid number of rows were changed: {}",
+                rows_affected
+            ));
+        }
+
+        Ok((tx, filelink))
+    }
+
+    /// Adds a new upload paper's details to the database. Sets the `from_library` field to false.
+    ///
+    /// Returns the database transaction and the id of the uploaded paper
+    // pub async fn add_uploaded_paper<'c>(
+    //     &self,
+    //     file_details:
+    // ) -> Result<(Transaction<'c, Postgres>, i32), color_eyre::eyre::Error> {
+    // }
+
+    /// Sets the `is_deleted` field to true and `approve_status` to false. Only deletes uploaded papers.
+    ///
+    /// Returns a boolean that represents whether a db entry was affected or not. If more than one entry was affected, an error will be thrown and the transaction will be rolled back.
+    pub async fn soft_delete(&self, id: i32) -> Result<bool, color_eyre::eyre::Error> {
+        let mut tx = self.connection.begin().await?;
+
+        let rows_affected = sqlx::query(queries::SOFT_DELETE_BY_ID)
+            .bind(id)
+            .execute(&mut *tx)
+            .await?
+            .rows_affected();
+
+        if rows_affected > 1 {
+            tx.rollback().await?;
+            Err(eyre!(
+                "Error: {} (> 1) papers were deleted. Rolling back.",
+                rows_affected
+            ))
+        } else {
+            tx.commit().await?;
+            Ok(rows_affected == 1)
+        }
+    }
+
+    pub async fn get_similar_papers(
+        &self,
+        course_code: String,
+        year: Option<i32>,
+        course_name: Option<String>,
+        semester: Option<String>,
+        exam: Option<String>,
+    ) -> Result<Vec<AdminDashboardQP>, sqlx::Error> {
+        let query_sql = queries::get_similar_papers_query(
+            year.is_some(),
+            course_name.is_some(),
+            semester.is_some(),
+            exam.is_some(),
+        );
+        let query = sqlx::query_as(&query_sql).bind(course_code);
+
+        let query = query.bind(year);
+        let query = query.bind(course_name);
+        let query = query.bind(semester);
+        let query = query.bind(exam);
+
+        let papers: Vec<models::DBAdminDashboardQP> = query.fetch_all(&self.connection).await?;
+
+        Ok(papers
+            .iter()
+            .map(|qp| qp::AdminDashboardQP::from(qp.clone()))
+            .collect())
+    }
+}
diff --git a/backend-rs/src/db/models.rs b/backend-rs/src/db/models.rs
new file mode 100644
index 0000000..ba5a802
--- /dev/null
+++ b/backend-rs/src/db/models.rs
@@ -0,0 +1,62 @@
+use crate::qp::Semester;
+
+    use super::qp;
+    use sqlx::{prelude::FromRow, types::chrono};
+
+    #[derive(FromRow, Clone)]
+    pub struct DBSearchQP {
+        id: i32,
+        filelink: String,
+        from_library: bool,
+        course_code: String,
+        course_name: String,
+        year: i32,
+        semester: String,
+        exam: String,
+    }
+
+    #[derive(FromRow, Clone)]
+    pub struct DBAdminDashboardQP {
+        id: i32,
+        filelink: String,
+        from_library: bool,
+        course_code: String,
+        course_name: String,
+        year: i32,
+        semester: String,
+        exam: String,
+        upload_timestamp: chrono::NaiveDateTime,
+        approve_status: bool,
+    }
+
+    impl From<DBAdminDashboardQP> for qp::AdminDashboardQP {
+        fn from(value: DBAdminDashboardQP) -> Self {
+            Self {
+                id: value.id,
+                filelink: value.filelink,
+                from_library: value.from_library,
+                course_code: value.course_code,
+                course_name: value.course_name,
+                year: value.year,
+                semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
+                exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
+                upload_timestamp: value.upload_timestamp.to_string(),
+                approve_status: value.approve_status,
+            }
+        }
+    }
+
+    impl From<DBSearchQP> for qp::SearchQP {
+        fn from(value: DBSearchQP) -> Self {
+            Self {
+                id: value.id,
+                filelink: value.filelink,
+                from_library: value.from_library,
+                course_code: value.course_code,
+                course_name: value.course_name,
+                year: value.year,
+                semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
+                exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
+            }
+        }
+    }
\ No newline at end of file
diff --git a/backend-rs/src/db/queries.rs b/backend-rs/src/db/queries.rs
new file mode 100644
index 0000000..44f5999
--- /dev/null
+++ b/backend-rs/src/db/queries.rs
@@ -0,0 +1,143 @@
+/// Query to get similar papers. Matches `course_code` ($1) always and other optional parameters
+pub fn get_similar_papers_query(
+	year: bool,
+	course_name: bool,
+	semester: bool,
+	exam: bool,
+) -> String {
+	let mut param_num = 1;
+
+	format!(
+		"SELECT {} from iqps where is_deleted=false and course_code = $1 {} {} {} {}",
+		ADMIN_DASHBOARD_QP_FIELDS,
+		if year {
+			param_num += 1;
+			format!("AND year=${}", param_num)
+		} else {
+			"".to_string()
+		},
+		if course_name {
+			param_num += 1;
+			format!("AND course_name=${}", param_num)
+		} else {
+			"".to_string()
+		},
+		if semester {
+			param_num += 1;
+			format!("AND semester=${}", param_num)
+		} else {
+			"".to_string()
+		},
+		if exam {
+			param_num += 1;
+			format!("AND exam=${}", param_num)
+		} else {
+			"".to_string()
+		},
+	)
+}
+
+/// Soft deletes a paper (sets `approve_status` to false and `is_deleted` to true) of an uploaded paper.
+pub const SOFT_DELETE_BY_ID: &str = "UPDATE iqps SET approve_status=false, is_deleted = true WHERE id=$1 AND from_library = false";
+
+/// Get a paper ([`crate::db::models::DBAdminDashboardQP`]) with the given id (first parameter `$1`)
+pub fn get_get_paper_by_id_query() -> String {
+	format!(
+		"SELECT {} FROM iqps WHERE id = $1",
+		ADMIN_DASHBOARD_QP_FIELDS
+	)
+}
+
+/// Returns a query that updates a paper's details by id ($1) (course_code, course_name, year, semester, exam, approve_status). `filelink` and `approved_by` optionally included if the edit is also used for approval.
+///
+/// Query parameters:
+/// - $1: `id`
+/// - $2: `course_code`
+/// - $3: `course_name`
+/// - $4: `year`
+/// - $5: `semester`
+/// - $6: `exam`
+/// - $7: `approve_status`
+/// - $8: `filelink`
+/// - $9: `approved_by`
+pub fn get_edit_paper_query(approval: bool) -> String {
+	format!(
+		"UPDATE iqps set course_code=$2, course_name=$3, year=$4, semester=$5, exam=$6, approve_status=$7{} WHERE id=$1 AND is_deleted=false",
+		if approval {", filelink=$8, approved_by=$9"} else {""}
+	)
+}
+
+/// Gets all unapproved papers ([`crate::db::models::DBAdminDashboardQP`]) from the database
+pub fn get_all_unapproved_query() -> String {
+	format!("SELECT {} FROM iqps WHERE approve_status = false and is_deleted=false ORDER BY upload_timestamp ASC", ADMIN_DASHBOARD_QP_FIELDS)
+}
+
+/// Searches for papers using the given query_text (parameter `$1`). This is total voodoo by Rajiv Harlalka. The second parameter can be used to filter by exam.
+/// // TODO: @Rajiv please update this documentation to explain the voodoo.
+const QP_SEARCH: &str = "
+with fuzzy as (
+select id,
+	   similarity(course_code || ' ' || course_name, $1) as sim_score,
+	   row_number() over (order by similarity(course_code || ' ' || course_name, $1) desc) as rank_ix
+from iqps
+where (course_code || ' ' || course_name) %>> $1 AND approve_status = true
+order by rank_ix
+limit 30
+),
+full_text as (
+select
+id,
+ts_rank_cd(fts_course_details, websearch_to_tsquery($1)) as rank_score,
+row_number() over(order by ts_rank_cd(fts_course_details , websearch_to_tsquery($1)) desc) as rank_ix
+from
+iqps
+where
+fts_course_details @@ websearch_to_tsquery($1)
+AND approve_status = true
+order by rank_ix
+limit 30
+),
+partial_search as (
+select id,
+ts_rank_cd(fts_course_details , to_tsquery('simple', websearch_to_tsquery('simple', $1)::text || ':*' )) as rank_score,
+row_number() over(order by ts_rank_cd(fts_course_details , to_tsquery('simple', websearch_to_tsquery('simple', $1)::text || ':*' )) desc) as rank_ix
+from iqps where
+  fts_course_details @@ to_tsquery(
+	'simple',
+	websearch_to_tsquery('simple', $1)::text || ':*'
+  )
+  AND approve_status = true
+limit 30
+),  result as (
+select
+iqps.id,iqps.course_code, iqps.course_name, iqps.year, iqps.exam, iqps.filelink, iqps.from_library, iqps.upload_timestamp, iqps.approve_status, iqps.semester
+from
+fuzzy
+full outer join full_text on fuzzy.id = full_text.id
+full outer join partial_search on coalesce(fuzzy.id, full_text.id) = partial_search.id
+join iqps on coalesce(fuzzy.id, full_text.id, partial_search.id) = iqps.id
+order by
+coalesce(1.0 / (50 + fuzzy.rank_ix), 0.0) * 1 +
+coalesce(1.0 / (50 + full_text.rank_ix), 0.0) * 1 +
+coalesce(1.0 / (50 + partial_search.rank_ix), 0.0) * 1
+desc
+)";
+
+pub fn get_qp_search_query(exam: bool) -> String {
+	let mut query = QP_SEARCH.to_owned();
+
+	query.push_str(&format!(" SELECT {} FROM result", SEARCH_QP_FIELDS));
+
+	if exam {
+		query.push_str(" WHERE (exam = $2 or exam = '')");
+	}
+
+	query
+}
+
+/// List of fields in the [`crate::db::models::DBAdminDashboardQP`] to be used with SELECT clauses
+pub const ADMIN_DASHBOARD_QP_FIELDS: &str = "id, filelink, from_library, course_code, course_name, year, semester, exam, upload_timestamp, approve_status";
+
+/// List of fields in the [`crate::db::models::DBSearchQP`] to be used with SELECT clauses
+pub const SEARCH_QP_FIELDS: &str =
+	"id, filelink, from_library, course_code, course_name, year, semester, exam";
\ No newline at end of file
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index db1226a..c83742e 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -356,3 +356,30 @@ pub async fn delete(
         ))
     }
 }
+
+#[derive(Deserialize)]
+pub struct SimilarReq {
+    course_code: String,
+    year: Option<i32>,
+    course_name: Option<String>,
+    semester: Option<String>,
+    exam: Option<String>,
+}
+
+pub async fn similar(
+    State(state): State<RouterState>,
+    Json(body): Json<SimilarReq>,
+) -> HandlerReturn<Vec<AdminDashboardQP>> {
+    let papers = state.db.get_similar_papers(
+        body.course_code,
+        body.year,
+        body.course_name,
+        body.semester,
+        body.exam,
+    ).await?;
+
+    Ok(BackendResponse::ok(
+        format!("Found {} similar papers.", papers.len()),
+        papers,
+    ))
+}
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index af8e24f..1d2daaa 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -29,6 +29,7 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
         .route("/profile", axum::routing::get(handlers::profile))
         .route("/edit", axum::routing::post(handlers::edit))
         .route("/delete", axum::routing::post(handlers::delete))
+        .route("/similar", axum::routing::post(handlers::similar))
         .route_layer(axum::middleware::from_fn_with_state(
             state.clone(),
             middleware::verify_jwt_middleware,

From 30a2033ec09588fd22a971227a48697f156d6f03 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 22:38:50 +0530
Subject: [PATCH 13/33] feat: fully working `/similar` GET endpoint

---
 backend-rs/src/db/mod.rs           |   8 +--
 backend-rs/src/db/models.rs        | 106 ++++++++++++++---------------
 backend-rs/src/db/queries.rs       |  95 +++++++++++++-------------
 backend-rs/src/routing/handlers.rs |  39 ++++++-----
 backend-rs/src/routing/mod.rs      |   8 ++-
 5 files changed, 133 insertions(+), 123 deletions(-)

diff --git a/backend-rs/src/db/mod.rs b/backend-rs/src/db/mod.rs
index 73300b2..1b09d30 100644
--- a/backend-rs/src/db/mod.rs
+++ b/backend-rs/src/db/mod.rs
@@ -194,11 +194,11 @@ impl Database {
 
     pub async fn get_similar_papers(
         &self,
-        course_code: String,
+        course_code: &str,
         year: Option<i32>,
-        course_name: Option<String>,
-        semester: Option<String>,
-        exam: Option<String>,
+        course_name: Option<&String>,
+        semester: Option<&String>,
+        exam: Option<&String>,
     ) -> Result<Vec<AdminDashboardQP>, sqlx::Error> {
         let query_sql = queries::get_similar_papers_query(
             year.is_some(),
diff --git a/backend-rs/src/db/models.rs b/backend-rs/src/db/models.rs
index ba5a802..b12b15b 100644
--- a/backend-rs/src/db/models.rs
+++ b/backend-rs/src/db/models.rs
@@ -1,62 +1,62 @@
 use crate::qp::Semester;
 
-    use super::qp;
-    use sqlx::{prelude::FromRow, types::chrono};
+use super::qp;
+use sqlx::{prelude::FromRow, types::chrono};
 
-    #[derive(FromRow, Clone)]
-    pub struct DBSearchQP {
-        id: i32,
-        filelink: String,
-        from_library: bool,
-        course_code: String,
-        course_name: String,
-        year: i32,
-        semester: String,
-        exam: String,
-    }
+#[derive(FromRow, Clone)]
+pub struct DBSearchQP {
+    id: i32,
+    filelink: String,
+    from_library: bool,
+    course_code: String,
+    course_name: String,
+    year: i32,
+    semester: String,
+    exam: String,
+}
 
-    #[derive(FromRow, Clone)]
-    pub struct DBAdminDashboardQP {
-        id: i32,
-        filelink: String,
-        from_library: bool,
-        course_code: String,
-        course_name: String,
-        year: i32,
-        semester: String,
-        exam: String,
-        upload_timestamp: chrono::NaiveDateTime,
-        approve_status: bool,
-    }
+#[derive(FromRow, Clone)]
+pub struct DBAdminDashboardQP {
+    id: i32,
+    filelink: String,
+    from_library: bool,
+    course_code: String,
+    course_name: String,
+    year: i32,
+    semester: String,
+    exam: String,
+    upload_timestamp: chrono::NaiveDateTime,
+    approve_status: bool,
+}
 
-    impl From<DBAdminDashboardQP> for qp::AdminDashboardQP {
-        fn from(value: DBAdminDashboardQP) -> Self {
-            Self {
-                id: value.id,
-                filelink: value.filelink,
-                from_library: value.from_library,
-                course_code: value.course_code,
-                course_name: value.course_name,
-                year: value.year,
-                semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
-                exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
-                upload_timestamp: value.upload_timestamp.to_string(),
-                approve_status: value.approve_status,
-            }
+impl From<DBAdminDashboardQP> for qp::AdminDashboardQP {
+    fn from(value: DBAdminDashboardQP) -> Self {
+        Self {
+            id: value.id,
+            filelink: value.filelink,
+            from_library: value.from_library,
+            course_code: value.course_code,
+            course_name: value.course_name,
+            year: value.year,
+            semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
+            exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
+            upload_timestamp: value.upload_timestamp.to_string(),
+            approve_status: value.approve_status,
         }
     }
+}
 
-    impl From<DBSearchQP> for qp::SearchQP {
-        fn from(value: DBSearchQP) -> Self {
-            Self {
-                id: value.id,
-                filelink: value.filelink,
-                from_library: value.from_library,
-                course_code: value.course_code,
-                course_name: value.course_name,
-                year: value.year,
-                semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
-                exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
-            }
+impl From<DBSearchQP> for qp::SearchQP {
+    fn from(value: DBSearchQP) -> Self {
+        Self {
+            id: value.id,
+            filelink: value.filelink,
+            from_library: value.from_library,
+            course_code: value.course_code,
+            course_name: value.course_name,
+            year: value.year,
+            semester: (&value.semester).try_into().unwrap_or(Semester::Unknown),
+            exam: (&value.exam).try_into().unwrap_or(qp::Exam::Unknown),
         }
-    }
\ No newline at end of file
+    }
+}
diff --git a/backend-rs/src/db/queries.rs b/backend-rs/src/db/queries.rs
index 44f5999..f7d855d 100644
--- a/backend-rs/src/db/queries.rs
+++ b/backend-rs/src/db/queries.rs
@@ -1,51 +1,52 @@
 /// Query to get similar papers. Matches `course_code` ($1) always and other optional parameters
 pub fn get_similar_papers_query(
-	year: bool,
-	course_name: bool,
-	semester: bool,
-	exam: bool,
+    year: bool,
+    course_name: bool,
+    semester: bool,
+    exam: bool,
 ) -> String {
-	let mut param_num = 1;
+    let mut param_num = 1;
 
-	format!(
-		"SELECT {} from iqps where is_deleted=false and course_code = $1 {} {} {} {}",
-		ADMIN_DASHBOARD_QP_FIELDS,
-		if year {
-			param_num += 1;
-			format!("AND year=${}", param_num)
-		} else {
-			"".to_string()
-		},
-		if course_name {
-			param_num += 1;
-			format!("AND course_name=${}", param_num)
-		} else {
-			"".to_string()
-		},
-		if semester {
-			param_num += 1;
-			format!("AND semester=${}", param_num)
-		} else {
-			"".to_string()
-		},
-		if exam {
-			param_num += 1;
-			format!("AND exam=${}", param_num)
-		} else {
-			"".to_string()
-		},
-	)
+    format!(
+        "SELECT {} from iqps where is_deleted=false and course_code = $1 {} {} {} {}",
+        ADMIN_DASHBOARD_QP_FIELDS,
+        if year {
+            param_num += 1;
+            format!("AND year=${}", param_num)
+        } else {
+            "".to_string()
+        },
+        if course_name {
+            param_num += 1;
+            format!("AND course_name=${}", param_num)
+        } else {
+            "".to_string()
+        },
+        if semester {
+            param_num += 1;
+            format!("AND semester=${}", param_num)
+        } else {
+            "".to_string()
+        },
+        if exam {
+            param_num += 1;
+            format!("AND exam=${}", param_num)
+        } else {
+            "".to_string()
+        },
+    )
 }
 
 /// Soft deletes a paper (sets `approve_status` to false and `is_deleted` to true) of an uploaded paper.
-pub const SOFT_DELETE_BY_ID: &str = "UPDATE iqps SET approve_status=false, is_deleted = true WHERE id=$1 AND from_library = false";
+pub const SOFT_DELETE_BY_ID: &str =
+    "UPDATE iqps SET approve_status=false, is_deleted = true WHERE id=$1 AND from_library = false";
 
 /// Get a paper ([`crate::db::models::DBAdminDashboardQP`]) with the given id (first parameter `$1`)
 pub fn get_get_paper_by_id_query() -> String {
-	format!(
-		"SELECT {} FROM iqps WHERE id = $1",
-		ADMIN_DASHBOARD_QP_FIELDS
-	)
+    format!(
+        "SELECT {} FROM iqps WHERE id = $1",
+        ADMIN_DASHBOARD_QP_FIELDS
+    )
 }
 
 /// Returns a query that updates a paper's details by id ($1) (course_code, course_name, year, semester, exam, approve_status). `filelink` and `approved_by` optionally included if the edit is also used for approval.
@@ -61,7 +62,7 @@ pub fn get_get_paper_by_id_query() -> String {
 /// - $8: `filelink`
 /// - $9: `approved_by`
 pub fn get_edit_paper_query(approval: bool) -> String {
-	format!(
+    format!(
 		"UPDATE iqps set course_code=$2, course_name=$3, year=$4, semester=$5, exam=$6, approve_status=$7{} WHERE id=$1 AND is_deleted=false",
 		if approval {", filelink=$8, approved_by=$9"} else {""}
 	)
@@ -69,7 +70,7 @@ pub fn get_edit_paper_query(approval: bool) -> String {
 
 /// Gets all unapproved papers ([`crate::db::models::DBAdminDashboardQP`]) from the database
 pub fn get_all_unapproved_query() -> String {
-	format!("SELECT {} FROM iqps WHERE approve_status = false and is_deleted=false ORDER BY upload_timestamp ASC", ADMIN_DASHBOARD_QP_FIELDS)
+    format!("SELECT {} FROM iqps WHERE approve_status = false and is_deleted=false ORDER BY upload_timestamp ASC", ADMIN_DASHBOARD_QP_FIELDS)
 }
 
 /// Searches for papers using the given query_text (parameter `$1`). This is total voodoo by Rajiv Harlalka. The second parameter can be used to filter by exam.
@@ -124,15 +125,15 @@ desc
 )";
 
 pub fn get_qp_search_query(exam: bool) -> String {
-	let mut query = QP_SEARCH.to_owned();
+    let mut query = QP_SEARCH.to_owned();
 
-	query.push_str(&format!(" SELECT {} FROM result", SEARCH_QP_FIELDS));
+    query.push_str(&format!(" SELECT {} FROM result", SEARCH_QP_FIELDS));
 
-	if exam {
-		query.push_str(" WHERE (exam = $2 or exam = '')");
-	}
+    if exam {
+        query.push_str(" WHERE (exam = $2 or exam = '')");
+    }
 
-	query
+    query
 }
 
 /// List of fields in the [`crate::db::models::DBAdminDashboardQP`] to be used with SELECT clauses
@@ -140,4 +141,4 @@ pub const ADMIN_DASHBOARD_QP_FIELDS: &str = "id, filelink, from_library, course_
 
 /// List of fields in the [`crate::db::models::DBSearchQP`] to be used with SELECT clauses
 pub const SEARCH_QP_FIELDS: &str =
-	"id, filelink, from_library, course_code, course_name, year, semester, exam";
\ No newline at end of file
+    "id, filelink, from_library, course_code, course_name, year, semester, exam";
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index c83742e..788eb02 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -3,6 +3,7 @@ use axum::{
     extract::{Json, Multipart},
     http::StatusCode,
 };
+use color_eyre::eyre::ContextCompat;
 use http::HeaderMap;
 use serde::Serialize;
 use tokio::fs;
@@ -357,26 +358,30 @@ pub async fn delete(
     }
 }
 
-#[derive(Deserialize)]
-pub struct SimilarReq {
-    course_code: String,
-    year: Option<i32>,
-    course_name: Option<String>,
-    semester: Option<String>,
-    exam: Option<String>,
-}
-
 pub async fn similar(
     State(state): State<RouterState>,
-    Json(body): Json<SimilarReq>,
+    Query(body): Query<HashMap<String, String>>,
 ) -> HandlerReturn<Vec<AdminDashboardQP>> {
-    let papers = state.db.get_similar_papers(
-        body.course_code,
-        body.year,
-        body.course_name,
-        body.semester,
-        body.exam,
-    ).await?;
+    if !body.contains_key("course_code") {
+        return Ok(BackendResponse::error(
+            "Error: `course_code` is required.".into(),
+            StatusCode::BAD_REQUEST,
+        ));
+    }
+
+    let papers = state
+        .db
+        .get_similar_papers(
+            body.get("course_code")
+                .context("Expected course code to be here.")?,
+            body.get("year")
+                .map(|year| year.parse::<i32>())
+                .transpose()?,
+            body.get("course_code"),
+            body.get("semester"),
+            body.get("exam"),
+        )
+        .await?;
 
     Ok(BackendResponse::ok(
         format!("Found {} similar papers.", papers.len()),
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 1d2daaa..2681828 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -1,6 +1,10 @@
 use std::sync::Arc;
 
-use axum::{extract::{DefaultBodyLimit, Json}, http::StatusCode, response::IntoResponse};
+use axum::{
+    extract::{DefaultBodyLimit, Json},
+    http::StatusCode,
+    response::IntoResponse,
+};
 use http::{HeaderValue, Method};
 use serde::Serialize;
 use tokio::sync::Mutex;
@@ -29,7 +33,7 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
         .route("/profile", axum::routing::get(handlers::profile))
         .route("/edit", axum::routing::post(handlers::edit))
         .route("/delete", axum::routing::post(handlers::delete))
-        .route("/similar", axum::routing::post(handlers::similar))
+        .route("/similar", axum::routing::get(handlers::similar))
         .route_layer(axum::middleware::from_fn_with_state(
             state.clone(),
             middleware::verify_jwt_middleware,

From 7d2c6009d0f933a5396a06e5213b9c6811d9963d Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Sat, 12 Oct 2024 22:45:31 +0530
Subject: [PATCH 14/33] feat: show currently running OCR in the sidebar

---
 frontend/src/pages/AdminDashboard.tsx          | 6 +++---
 frontend/src/pages/styles/admin_dashboard.scss | 6 ++++++
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/frontend/src/pages/AdminDashboard.tsx b/frontend/src/pages/AdminDashboard.tsx
index d4981a4..92980e8 100644
--- a/frontend/src/pages/AdminDashboard.tsx
+++ b/frontend/src/pages/AdminDashboard.tsx
@@ -19,6 +19,7 @@ function AdminDashboard() {
 	const [awaitingResponse, setAwaitingResponse] = useState<boolean>(false);
 	const [ocrDetails, setOcrDetails] = useState<Map<number, IExtractedDetails>>(new Map());
 	const [ocrRequests, setOcrRequests] = useState<IAdminDashboardQP[]>([]);
+	const [ocrMessage, setOcrMessage] = useState<string | null>(null);
 	const [ocrLoopOn, setOcrLoopOn] = useState<boolean>(false);
 
 	const [selectedQPaper, setSelectedQPaper] =
@@ -94,7 +95,7 @@ function AdminDashboard() {
 
 	const storeOcrDetails = async (paper: IAdminDashboardQP) => {
 		if (!ocrDetails.has(paper.id)) {
-			const toastId = toast.loading(`Running OCR for ${paper.course_name} - ${paper.course_code} (id: ${paper.id})`);
+			setOcrMessage(`Running OCR for ${paper.course_name} - ${paper.course_code} (id: ${paper.id})`);
 			const response = await fetch(paper.filelink);
 
 			if (response.ok) {
@@ -102,8 +103,6 @@ function AdminDashboard() {
 				const pdfText = await extractTextFromPDF(pdfData);
 
 				setOcrDetails((currentValue) => currentValue.set(paper.id, extractDetailsFromText(pdfText)));
-				toast.dismiss(toastId);
-				toast.success(`OCR completed for ${paper.course_name} - ${paper.course_code} (id: ${paper.id})`);
 			}
 		}
 	}
@@ -148,6 +147,7 @@ function AdminDashboard() {
 							<p><b>Unapproved papers</b>: {unapprovedPapers.length}</p>
 							<p><b>Unique Course Codes</b>: {numUniqueCourseCodes}</p>
 							<p><b>OCR details</b>: {ocrDetails.size} papers (loop {ocrLoopOn ? 'On' : 'Off'})</p>
+							{ocrMessage !== null &&<p>{ocrMessage}</p>}
 						</div>
 						<div className="papers-panel">
 							{unapprovedPapers.map((paper, i) => <QPCard
diff --git a/frontend/src/pages/styles/admin_dashboard.scss b/frontend/src/pages/styles/admin_dashboard.scss
index bc94442..d410893 100644
--- a/frontend/src/pages/styles/admin_dashboard.scss
+++ b/frontend/src/pages/styles/admin_dashboard.scss
@@ -5,6 +5,12 @@
 	flex-direction: column;
 	justify-items: center;
 
+	padding: 0 1rem;
+
+	.side-panel {
+		width: 20%;
+	}
+
 	.dashboard-container {
 		display: flex;
 		gap: 2rem;

From e882f8fc9fe1f4b3f0e1bb095ce6b74c10821eda Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Wed, 16 Oct 2024 18:57:35 +0530
Subject: [PATCH 15/33] refactor: moved all path related stuff to pathutils
 module

---
 backend-rs/.env.template           |   1 +
 backend-rs/src/db/mod.rs           |  78 ++++++++++++++---
 backend-rs/src/db/queries.rs       |   7 ++
 backend-rs/src/env.rs              |  46 ++++------
 backend-rs/src/main.rs             |   1 +
 backend-rs/src/pathutils.rs        | 115 +++++++++++++++++++++++++
 backend-rs/src/qp.rs               |   8 +-
 backend-rs/src/routing/handlers.rs | 134 +++++++++++++++++++----------
 backend-rs/src/routing/mod.rs      |   2 +
 9 files changed, 298 insertions(+), 94 deletions(-)
 create mode 100644 backend-rs/src/pathutils.rs

diff --git a/backend-rs/.env.template b/backend-rs/.env.template
index f99a46b..edf19c4 100644
--- a/backend-rs/.env.template
+++ b/backend-rs/.env.template
@@ -18,6 +18,7 @@ LOG_LOCATION=./log/application.log
 STATIC_FILES_URL=https://static.metakgp.org
 STATIC_FILE_STORAGE_LOCATION=/srv/static
 UPLOADED_QPS_PATH=iqps/uploaded
+LIBRARY_QPS_PATH=peqp/qp
 
 SERVER_PORT=8080
 
diff --git a/backend-rs/src/db/mod.rs b/backend-rs/src/db/mod.rs
index 1b09d30..c4ad24e 100644
--- a/backend-rs/src/db/mod.rs
+++ b/backend-rs/src/db/mod.rs
@@ -1,10 +1,12 @@
-use color_eyre::eyre::{eyre, ContextCompat};
-use sqlx::{postgres::PgPoolOptions, PgPool, Postgres, Transaction};
+use color_eyre::eyre::eyre;
+use sqlx::{postgres::PgPoolOptions, prelude::FromRow, PgPool, Postgres, Transaction};
 use std::time::Duration;
 
 use crate::{
     env::EnvVars,
+    pathutils::PaperCategory,
     qp::{self, AdminDashboardQP, Exam, Semester},
+    routing::FileDetails,
 };
 
 mod models;
@@ -24,6 +26,11 @@ pub struct EditDetails {
     pub approve_status: bool,
 }
 
+#[derive(FromRow)]
+struct Breh {
+    id: i32,
+}
+
 impl Database {
     pub async fn try_new(env_vars: &EnvVars) -> Result<Self, sqlx::Error> {
         let database_url = format!(
@@ -129,15 +136,16 @@ impl Database {
             .bind(approve_status);
 
         let filelink = env_vars
-            .get_uploaded_paper_slugs()
-            .approved
-            .join(format!(
-                "{}_{}_{}_{}_{}_{}.pdf",
-                id, course_code, course_name, year, semester, exam
-            ))
-            .to_str()
-            .context("Error converting approved papers path to string.")?
-            .to_owned();
+            .paths
+            .get_slug(
+                &format!(
+                    "{}_{}_{}_{}_{}_{}.pdf",
+                    id, course_code, course_name, year, semester, exam
+                ),
+                PaperCategory::Approved,
+            )
+            .to_string_lossy()
+            .to_string();
 
         let query = if newly_approved {
             query.bind(&filelink).bind(username)
@@ -220,4 +228,52 @@ impl Database {
             .map(|qp| qp::AdminDashboardQP::from(qp.clone()))
             .collect())
     }
+
+    /// Inserts a new uploaded question paper into the database. Uses a placeholder for the filelink which should be replaced once the id is known using the [crate::db::Database::update_uploaded_filelink] function.
+    ///
+    /// Returns a tuple with the transaction and the id of the inserted paper.
+    pub async fn insert_new_uploaded_qp<'c>(
+        &self,
+        file_details: &FileDetails,
+    ) -> Result<(Transaction<'c, Postgres>, i32), color_eyre::eyre::Error> {
+        let mut tx = self.connection.begin().await?;
+
+        let FileDetails {
+            course_code,
+            course_name,
+            year,
+            exam,
+            semester,
+            ..
+        } = file_details;
+
+        let query = sqlx::query_as(queries::INSERT_NEW_QP)
+            .bind(course_code)
+            .bind(course_name)
+            .bind(year)
+            .bind(exam)
+            .bind(semester)
+            .bind("placeholder_filelink")
+            .bind(false);
+
+        let Breh { id } = query.fetch_one(&mut *tx).await?;
+
+        Ok((tx, id))
+    }
+
+    // /// Updates filelink for an uploaded question paper uploaded using the [crate::db::Database::update_uploaded_filelink] function. Takes the same transaction that the previous function used.
+    pub async fn update_uploaded_filelink<'c>(
+        &self,
+        tx: &mut Transaction<'c, Postgres>,
+        id: i32,
+        file_link: &str,
+    ) -> Result<(), color_eyre::eyre::Error> {
+        let query = sqlx::query(queries::UPDATE_FILELINK)
+            .bind(id)
+            .bind(file_link);
+
+        query.execute(&mut **tx).await?;
+
+        Ok(())
+    }
 }
diff --git a/backend-rs/src/db/queries.rs b/backend-rs/src/db/queries.rs
index f7d855d..20b0bf1 100644
--- a/backend-rs/src/db/queries.rs
+++ b/backend-rs/src/db/queries.rs
@@ -142,3 +142,10 @@ pub const ADMIN_DASHBOARD_QP_FIELDS: &str = "id, filelink, from_library, course_
 /// List of fields in the [`crate::db::models::DBSearchQP`] to be used with SELECT clauses
 pub const SEARCH_QP_FIELDS: &str =
     "id, filelink, from_library, course_code, course_name, year, semester, exam";
+
+/// Insert a newly uploaded file in the db (and return the id)
+/// Parameters in the following order: `course_code`, `course_name`, `year`, `exam`, `semester`, `filelink`, `from_library`
+pub const INSERT_NEW_QP: &str = "INSERT INTO iqps (course_code, course_name, year, exam, semester, filelink, from_library) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING id";
+
+/// Updates the filelink ($2) of a paper with the given id ($1). Used to update the filelink after a paper is uploaded.
+pub const UPDATE_FILELINK: &str = "UPDATE iqps SET filelink=$2 WHERE id=$1";
diff --git a/backend-rs/src/env.rs b/backend-rs/src/env.rs
index 7d18ecb..d40b02d 100644
--- a/backend-rs/src/env.rs
+++ b/backend-rs/src/env.rs
@@ -4,6 +4,8 @@ use clap::Parser;
 use hmac::{digest::InvalidLength, Hmac, Mac};
 use sha2::Sha256;
 
+use crate::pathutils::Paths;
+
 #[derive(Parser, Clone)]
 pub struct EnvVars {
     // Database
@@ -54,13 +56,16 @@ pub struct EnvVars {
     // Paths
     #[arg(env, default_value = "https://static.metakgp.org")]
     /// The URL of the static files server (odin's vault)
-    pub static_files_url: String,
+    static_files_url: String,
     #[arg(env, default_value = "/srv/static")]
     /// The path where static files are served from
-    pub static_file_storage_location: PathBuf,
+    static_file_storage_location: PathBuf,
     #[arg(env, default_value = "/iqps/uploaded")]
     /// The path where uploaded papers are stored temporarily, relative to the `static_file_storage_location`
-    pub uploaded_qps_path: PathBuf,
+    uploaded_qps_path: PathBuf,
+    #[arg(env, default_value = "/peqp/qp")]
+    /// The path where library papers (scrapped) are stored, relative to the `static_file_storage_location`
+    library_qps_path: PathBuf,
 
     // Server
     #[arg(env, default_value = "8080")]
@@ -71,23 +76,22 @@ pub struct EnvVars {
     #[arg(env, default_value = "https://qp.metakgp.org,http://localhost:5173")]
     /// List of origins allowed (as a list of values separated by commas `origin1, origin2`)
     pub cors_allowed_origins: String,
-}
 
-pub struct UploadPaths {
-    pub unapproved: PathBuf,
-    pub approved: PathBuf,
+    #[arg(skip)]
+    pub paths: Paths,
 }
 
 impl EnvVars {
     /// Processes the environment variables after reading.
     pub fn process(mut self) -> Result<Self, Box<dyn std::error::Error>> {
-        self.static_file_storage_location = std::path::absolute(self.static_file_storage_location)?;
-        self.uploaded_qps_path = std::path::absolute(
-            self.static_file_storage_location
-                .join(self.uploaded_qps_path),
+        self.paths = Paths::new(
+            &self.static_files_url,
+            &self.static_file_storage_location,
+            &self.uploaded_qps_path,
+            &self.library_qps_path,
         )?;
-
         self.log_location = std::path::absolute(self.log_location)?;
+
         Ok(self)
     }
 
@@ -95,22 +99,4 @@ impl EnvVars {
     pub fn get_jwt_key(&self) -> Result<Hmac<Sha256>, InvalidLength> {
         Hmac::new_from_slice(self.jwt_secret.as_bytes())
     }
-
-    /// Gets the paths where (unapproved, approved) uploaded papers are stored
-    pub fn get_uploaded_paper_paths(&self) -> UploadPaths {
-        let slugs = self.get_uploaded_paper_slugs();
-
-        UploadPaths {
-            unapproved: self.static_file_storage_location.join(slugs.unapproved),
-            approved: self.static_file_storage_location.join(slugs.approved),
-        }
-    }
-
-    /// Gets the slugs (relative paths stored in the db) where (unapproved, approved) uploaded papers are stored
-    pub fn get_uploaded_paper_slugs(&self) -> UploadPaths {
-        UploadPaths {
-            unapproved: self.uploaded_qps_path.join("unapproved"),
-            approved: self.uploaded_qps_path.join("approved"),
-        }
-    }
 }
diff --git a/backend-rs/src/main.rs b/backend-rs/src/main.rs
index 40b4f89..3c6cee7 100644
--- a/backend-rs/src/main.rs
+++ b/backend-rs/src/main.rs
@@ -4,6 +4,7 @@ use tracing_subscriber::prelude::*;
 mod auth;
 mod db;
 mod env;
+mod pathutils;
 mod qp;
 mod routing;
 
diff --git a/backend-rs/src/pathutils.rs b/backend-rs/src/pathutils.rs
new file mode 100644
index 0000000..b751e25
--- /dev/null
+++ b/backend-rs/src/pathutils.rs
@@ -0,0 +1,115 @@
+use std::path::{self, Path, PathBuf};
+
+use url::Url;
+
+/// A category of papers, can also be used to represent the directory where these papers are stored
+pub enum PaperCategory {
+    Unapproved,
+    Approved,
+    Library,
+}
+
+#[derive(Clone, Default)]
+/// A set of paths (absolute, relative, or even URLs) for all three categories of papers (directories)
+struct PathTriad {
+    pub unapproved: PathBuf,
+    pub approved: PathBuf,
+    pub library: PathBuf,
+}
+
+impl PathTriad {
+    pub fn get(&self, category: PaperCategory) -> PathBuf {
+        match category {
+            PaperCategory::Approved => self.approved.to_owned(),
+            PaperCategory::Unapproved => self.unapproved.to_owned(),
+            PaperCategory::Library => self.library.to_owned(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Paths {
+    /// URL of the static files server
+    static_files_url: Url,
+    /// The absolute path to the location from where the static files server serves files
+    static_files_path: PathBuf,
+
+    /// The absolute system paths to all three directories on the server
+    system_paths: PathTriad,
+
+    /// The slugs to all three directories
+    ///
+    /// A slug is a relative path independent of the URL or system path. This slug is stored in the database and either the [`crate::pathutils::Paths::static_files_url`] or the [`crate::pathutils::Paths::static_files_path`] is prepended to it to get its URL (to send to the frontend) or the system path (for backend operations)
+    path_slugs: PathTriad,
+}
+
+impl Default for Paths {
+    fn default() -> Self {
+        Self {
+            static_files_url: Url::parse("https://metakgp.org")
+                .expect("This library thinks https://metakgp.org is not a valid URL."),
+            static_files_path: PathBuf::default(),
+            system_paths: PathTriad::default(),
+            path_slugs: PathTriad::default(),
+        }
+    }
+}
+
+impl Paths {
+    pub fn new(
+        static_files_url: &str,
+        static_file_storage_location: &Path,
+        uploaded_qps_relative_path: &Path,
+        library_qps_relative_path: &Path,
+    ) -> Result<Self, color_eyre::eyre::Error> {
+        let path_slugs = PathTriad {
+            unapproved: uploaded_qps_relative_path.join("unapproved"),
+            approved: uploaded_qps_relative_path.join("approved"),
+            library: library_qps_relative_path.to_owned(),
+        };
+
+        let system_paths = PathTriad {
+            unapproved: path::absolute(static_file_storage_location.join(&path_slugs.unapproved))?,
+            approved: path::absolute(static_file_storage_location.join(&path_slugs.approved))?,
+            library: path::absolute(static_file_storage_location.join(&path_slugs.library))?,
+        };
+
+        Ok(Self {
+            static_files_url: Url::parse(static_files_url)?,
+            static_files_path: path::absolute(static_file_storage_location)?,
+            system_paths,
+            path_slugs,
+        })
+    }
+
+    pub fn get_slug(&self, filename: &str, category: PaperCategory) -> PathBuf {
+        self.path_slugs.get(category).join(filename)
+    }
+
+    pub fn get_path(&self, filename: &str, dir: PaperCategory) -> PathBuf {
+        self.system_paths.get(dir).join(filename)
+    }
+
+    pub fn get_path_from_slug(&self, slug: &str) -> PathBuf {
+        self.static_files_path.join(slug)
+    }
+
+    pub fn get_url(
+        &self,
+        filename: &str,
+        dir: PaperCategory,
+    ) -> Result<String, color_eyre::eyre::Error> {
+        let slug = self
+            .path_slugs
+            .get(dir)
+            .join(filename)
+            .to_string_lossy()
+            .into_owned();
+
+        self.get_url_from_slug(&slug)
+    }
+
+    pub fn get_url_from_slug(&self, slug: &str) -> Result<String, color_eyre::eyre::Error> {
+        Ok(self.static_files_url.join(slug)?.as_str().to_string())
+    }
+}
diff --git a/backend-rs/src/qp.rs b/backend-rs/src/qp.rs
index fee7c87..309b83d 100644
--- a/backend-rs/src/qp.rs
+++ b/backend-rs/src/qp.rs
@@ -3,7 +3,6 @@ use std::path::PathBuf;
 use color_eyre::eyre::eyre;
 use duplicate::duplicate_item;
 use serde::Serialize;
-use url::Url;
 
 use crate::env::EnvVars;
 
@@ -133,16 +132,13 @@ pub struct AdminDashboardQP {
 )]
 impl QP {
     pub fn with_url(self, env_vars: &EnvVars) -> Result<Self, color_eyre::eyre::Error> {
-        let url = Url::parse(&env_vars.static_files_url)?;
-        let url = url.join(&self.filelink)?;
-
         Ok(Self {
-            filelink: url.to_string(),
+            filelink: env_vars.paths.get_url_from_slug(&self.filelink)?,
             ..self
         })
     }
 
     pub fn get_paper_path(&self, env_vars: &EnvVars) -> PathBuf {
-        env_vars.static_file_storage_location.join(&self.filelink)
+        env_vars.paths.get_path_from_slug(&self.filelink)
     }
 }
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index 788eb02..f4fb484 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -16,6 +16,7 @@ use serde::Deserialize;
 use crate::{
     auth,
     db::EditDetails,
+    pathutils::PaperCategory,
     qp::{self, AdminDashboardQP, Exam, Semester},
 };
 
@@ -189,7 +190,7 @@ pub async fn edit(
 
         // Copy the actual file
         let old_filepath = current_details.get_paper_path(&state.env_vars);
-        let new_filepath = state.env_vars.static_file_storage_location.join(filelink);
+        let new_filepath = state.env_vars.paths.get_path_from_slug(&filelink);
 
         if fs::copy(old_filepath, new_filepath).await.is_ok() {
             // Commit the transaction
@@ -219,12 +220,12 @@ pub async fn edit(
 
 #[derive(Deserialize)]
 pub struct FileDetails {
-    course_code: String,
-    course_name: String,
-    year: i32,
-    exam: String,
-    semester: String,
-    filename: String,
+    pub course_code: String,
+    pub course_name: String,
+    pub year: i32,
+    pub exam: String,
+    pub semester: String,
+    pub filename: String,
 }
 
 /// 10 MiB file size limit
@@ -280,54 +281,93 @@ pub async fn upload(
         ));
     }
 
-    let upload_statuses: Vec<UploadStatus> = files
-        .iter()
-        .zip(file_details.iter())
-        .map(|((file_headers, file_data), details)| {
-            let FileDetails {
-                course_code,
-                course_name,
-                year,
-                exam,
-                semester,
-                filename,
-            } = details;
-
-            if file_data.len() > FILE_SIZE_LIMIT {
-                return UploadStatus {
+    let files_iter = files.iter().zip(file_details.iter());
+    let mut upload_statuses = Vec::<UploadStatus>::new();
+
+    for ((file_headers, file_data), details) in files_iter {
+        let FileDetails {
+            course_code,
+            course_name,
+            year,
+            exam,
+            semester,
+            filename,
+        } = details;
+
+        if file_data.len() > FILE_SIZE_LIMIT {
+            upload_statuses.push(UploadStatus {
+                filename: filename.to_owned(),
+                status: Status::Error,
+                message: format!(
+                    "File size too big. Only files upto {} MiB are allowed.",
+                    FILE_SIZE_LIMIT >> 20
+                ),
+            });
+            continue;
+        }
+
+        if let Some(content_type) = file_headers.get("content-type") {
+            if content_type != "application/pdf" {
+                upload_statuses.push(UploadStatus {
                     filename: filename.to_owned(),
                     status: Status::Error,
-                    message: format!(
-                        "File size too big. Only files upto {} MiB are allowed.",
-                        FILE_SIZE_LIMIT >> 20
-                    ),
-                };
+                    message: "Only PDFs are supported.".into(),
+                });
+                continue;
             }
+        } else {
+            upload_statuses.push(UploadStatus {
+                filename: filename.to_owned(),
+                status: Status::Error,
+                message: "`content-type` header not found. File type could not be determined."
+                    .into(),
+            });
+            continue;
+        }
+
+        // Insert the db entry
+        let (mut tx, id) = state.db.insert_new_uploaded_qp(details).await?;
+
+        // Create the new filelink (slug)
+        let filelink_slug = state
+            .env_vars
+            .paths
+            .get_slug(&format!("{}.pdf", id), PaperCategory::Unapproved)
+            .to_string_lossy()
+            .to_string();
 
-            if let Some(content_type) = file_headers.get("content-type") {
-                if content_type != "application/pdf" {
-                    return UploadStatus {
-                        filename: filename.to_owned(),
-                        status: Status::Error,
-                        message: "Only PDFs are supported.".into(),
-                    };
-                }
+        // Update the filelink in the db
+        if state
+            .db
+            .update_uploaded_filelink(&mut tx, id, &filelink_slug)
+            .await
+            .is_ok()
+        {
+            let filepath = state.env_vars.paths.get_path_from_slug(&filelink_slug);
+            // Write the file data
+            if fs::write(filepath, file_data).await.is_ok() {
             } else {
-                return UploadStatus {
-                    filename: filename.to_owned(),
-                    status: Status::Error,
-                    message: "`content-type` header not found. File type could not be determined."
-                        .into(),
-                };
+                tx.rollback().await?;
             }
 
-            UploadStatus {
-                filename: "()".into(),
+            // If the write fails, rollback the transaction, else commit it.
+        } else {
+            tx.rollback().await?;
+
+            upload_statuses.push(UploadStatus {
+                filename: filename.to_owned(),
                 status: Status::Error,
-                message: "()".into(),
-            }
-        })
-        .collect::<Vec<UploadStatus>>();
+                message: "Error updating the filelink".into(),
+            });
+            continue;
+        }
+
+        upload_statuses.push(UploadStatus {
+            filename: "()".into(),
+            status: Status::Error,
+            message: "()".into(),
+        });
+    }
 
     Ok(BackendResponse::ok(
         format!("Successfully processed {} files", upload_statuses.len()),
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 2681828..162ade5 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -21,6 +21,8 @@ use crate::{
 mod handlers;
 mod middleware;
 
+pub use handlers::FileDetails;
+
 pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
     let state = RouterState {
         db,

From ef3ef2972fa45791a66e27726fa69c70a21df2a0 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Wed, 16 Oct 2024 19:06:25 +0530
Subject: [PATCH 16/33] feat: (hopefully) fully functional upload endpoint

---
 backend-rs/src/db/mod.rs           | 18 +++++--------
 backend-rs/src/pathutils.rs        |  8 ++++--
 backend-rs/src/routing/handlers.rs | 43 ++++++++++++++++++------------
 3 files changed, 39 insertions(+), 30 deletions(-)

diff --git a/backend-rs/src/db/mod.rs b/backend-rs/src/db/mod.rs
index c4ad24e..70df5fc 100644
--- a/backend-rs/src/db/mod.rs
+++ b/backend-rs/src/db/mod.rs
@@ -135,17 +135,13 @@ impl Database {
             .bind(&exam)
             .bind(approve_status);
 
-        let filelink = env_vars
-            .paths
-            .get_slug(
-                &format!(
-                    "{}_{}_{}_{}_{}_{}.pdf",
-                    id, course_code, course_name, year, semester, exam
-                ),
-                PaperCategory::Approved,
-            )
-            .to_string_lossy()
-            .to_string();
+        let filelink = env_vars.paths.get_slug(
+            &format!(
+                "{}_{}_{}_{}_{}_{}.pdf",
+                id, course_code, course_name, year, semester, exam
+            ),
+            PaperCategory::Approved,
+        );
 
         let query = if newly_approved {
             query.bind(&filelink).bind(username)
diff --git a/backend-rs/src/pathutils.rs b/backend-rs/src/pathutils.rs
index b751e25..7a70376 100644
--- a/backend-rs/src/pathutils.rs
+++ b/backend-rs/src/pathutils.rs
@@ -82,8 +82,12 @@ impl Paths {
         })
     }
 
-    pub fn get_slug(&self, filename: &str, category: PaperCategory) -> PathBuf {
-        self.path_slugs.get(category).join(filename)
+    pub fn get_slug(&self, filename: &str, category: PaperCategory) -> String {
+        self.path_slugs
+            .get(category)
+            .join(filename)
+            .to_string_lossy()
+            .to_string()
     }
 
     pub fn get_path(&self, filename: &str, dir: PaperCategory) -> PathBuf {
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index f4fb484..d4b4f8c 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -285,18 +285,11 @@ pub async fn upload(
     let mut upload_statuses = Vec::<UploadStatus>::new();
 
     for ((file_headers, file_data), details) in files_iter {
-        let FileDetails {
-            course_code,
-            course_name,
-            year,
-            exam,
-            semester,
-            filename,
-        } = details;
+        let filename = details.filename.to_owned();
 
         if file_data.len() > FILE_SIZE_LIMIT {
             upload_statuses.push(UploadStatus {
-                filename: filename.to_owned(),
+                filename,
                 status: Status::Error,
                 message: format!(
                     "File size too big. Only files upto {} MiB are allowed.",
@@ -317,7 +310,7 @@ pub async fn upload(
             }
         } else {
             upload_statuses.push(UploadStatus {
-                filename: filename.to_owned(),
+                filename,
                 status: Status::Error,
                 message: "`content-type` header not found. File type could not be determined."
                     .into(),
@@ -332,9 +325,7 @@ pub async fn upload(
         let filelink_slug = state
             .env_vars
             .paths
-            .get_slug(&format!("{}.pdf", id), PaperCategory::Unapproved)
-            .to_string_lossy()
-            .to_string();
+            .get_slug(&format!("{}.pdf", id), PaperCategory::Unapproved);
 
         // Update the filelink in the db
         if state
@@ -344,8 +335,26 @@ pub async fn upload(
             .is_ok()
         {
             let filepath = state.env_vars.paths.get_path_from_slug(&filelink_slug);
+
             // Write the file data
-            if fs::write(filepath, file_data).await.is_ok() {
+            if fs::write(&filepath, file_data).await.is_ok() {
+                if tx.commit().await.is_ok() {
+                    upload_statuses.push(UploadStatus {
+                        filename,
+                        status: Status::Success,
+                        message: "Succesfully uploaded file.".into(),
+                    });
+                    continue;
+                } else {
+                    // Transaction commit failed, delete the file
+                    fs::remove_file(filepath).await?;
+                    upload_statuses.push(UploadStatus {
+                        filename,
+                        status: Status::Success,
+                        message: "Succesfully uploaded file.".into(),
+                    });
+                    continue;
+                }
             } else {
                 tx.rollback().await?;
             }
@@ -355,7 +364,7 @@ pub async fn upload(
             tx.rollback().await?;
 
             upload_statuses.push(UploadStatus {
-                filename: filename.to_owned(),
+                filename,
                 status: Status::Error,
                 message: "Error updating the filelink".into(),
             });
@@ -363,9 +372,9 @@ pub async fn upload(
         }
 
         upload_statuses.push(UploadStatus {
-            filename: "()".into(),
+            filename,
             status: Status::Error,
-            message: "()".into(),
+            message: "THIS SHOULD NEVER HAPPEN. REPORT IMMEDIATELY. ALSO THIS WOULDN'T HAPPEN IF RUST HAD STABLE ASYNC CLOSURES.".into(),
         });
     }
 

From 0f03898a28b45d89af96910273b5a3be90ea5d5e Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 17 Oct 2024 01:21:11 +0530
Subject: [PATCH 17/33] feat: working(?) /edit handler

---
 backend-rs/src/db/mod.rs           | 107 ++++++++++++++++-------------
 backend-rs/src/db/queries.rs       |   9 ++-
 backend-rs/src/routing/handlers.rs |  52 ++------------
 backend-rs/src/routing/mod.rs      |   2 +-
 4 files changed, 73 insertions(+), 97 deletions(-)

diff --git a/backend-rs/src/db/mod.rs b/backend-rs/src/db/mod.rs
index 70df5fc..479ab17 100644
--- a/backend-rs/src/db/mod.rs
+++ b/backend-rs/src/db/mod.rs
@@ -1,4 +1,5 @@
 use color_eyre::eyre::eyre;
+use models::DBAdminDashboardQP;
 use sqlx::{postgres::PgPoolOptions, prelude::FromRow, PgPool, Postgres, Transaction};
 use std::time::Duration;
 
@@ -6,7 +7,7 @@ use crate::{
     env::EnvVars,
     pathutils::PaperCategory,
     qp::{self, AdminDashboardQP, Exam, Semester},
-    routing::FileDetails,
+    routing::{EditReq, FileDetails},
 };
 
 mod models;
@@ -17,15 +18,6 @@ pub struct Database {
     connection: PgPool,
 }
 
-pub struct EditDetails {
-    pub course_code: String,
-    pub course_name: String,
-    pub year: i32,
-    pub semester: Semester,
-    pub exam: Exam,
-    pub approve_status: bool,
-}
-
 #[derive(FromRow)]
 struct Breh {
     id: i32,
@@ -98,69 +90,90 @@ impl Database {
 
     /// Edit's a paper's details.
     ///
-    /// - If the paper is approved, the filename is also changed and it is moved to `/static_file_storage_location/uploaded_qps_path/approved/`.
-    /// - If the paper is unapproved, the file is not moved again, same goes for library papers.
     /// - Sets the `approved_by` field to the username if approved.
+    /// - Sets the `filelink` to:
+    ///     - For library papers, remains unchanged
+    ///     - For uploaded papers, approved papers are moved to the approved directory and renamed `id_coursecode_coursename_year_semester_exam.pdf` and unapproved papers are moved to the unapproved directory and named `id.pdf`
     ///
-    /// Returns the database transaction and the new filelink
+    /// Returns the database transaction, the old filelink and the new paper details ([`crate::qp::AdminDashboardQP`])
     pub async fn edit_paper<'c>(
         &self,
-        id: i32,
-        edit_details: EditDetails,
-        newly_approved: bool,
+        edit_req: EditReq,
         username: &str,
         env_vars: &EnvVars,
-    ) -> Result<(Transaction<'c, Postgres>, String), color_eyre::eyre::Error> {
-        let mut tx = self.connection.begin().await?;
-
-        let EditDetails {
+    ) -> Result<(Transaction<'c, Postgres>, String, AdminDashboardQP), color_eyre::eyre::Error>
+    {
+        let EditReq {
+            id,
             course_code,
             course_name,
             year,
             semester,
             exam,
             approve_status,
-        } = edit_details;
+        } = edit_req;
+
+        let current_details = self.get_paper_by_id(id).await?;
+
+        // Construct the final values to be inserted into the db
+        let course_code = course_code.unwrap_or(current_details.course_code);
+        let course_name = course_name.unwrap_or(current_details.course_name);
+        let year = year.unwrap_or(current_details.year);
+        let semester: String = if let Some(semester) = semester {
+            Semester::try_from(&semester)?
+        } else {
+            current_details.semester
+        }
+        .into();
+        let exam: String = if let Some(exam) = exam {
+            Exam::try_from(&exam)?
+        } else {
+            current_details.exam
+        }
+        .into();
+        let approve_status = approve_status.unwrap_or(current_details.approve_status);
+
+        // Set the new filelink
+        let old_filelink = current_details.filelink;
+        let new_filelink = if current_details.from_library {
+            old_filelink.clone()
+        } else if approve_status {
+            env_vars.paths.get_slug(
+                &format!(
+                    "{}_{}_{}_{}_{}_{}.pdf",
+                    id, course_code, course_name, year, semester, exam
+                ),
+                PaperCategory::Approved,
+            )
+        } else {
+            env_vars
+                .paths
+                .get_slug(&format!("{}.pdf", id), PaperCategory::Unapproved)
+        };
 
-        let semester = String::from(semester);
-        let exam = String::from(exam);
+        let mut tx = self.connection.begin().await?;
 
-        let query_sql = queries::get_edit_paper_query(newly_approved);
-        let query = sqlx::query(&query_sql)
+        let query_sql = queries::get_edit_paper_query(approve_status);
+        let query = sqlx::query_as(&query_sql)
             .bind(id)
             .bind(&course_code)
             .bind(&course_name)
             .bind(year)
             .bind(&semester)
             .bind(&exam)
-            .bind(approve_status);
-
-        let filelink = env_vars.paths.get_slug(
-            &format!(
-                "{}_{}_{}_{}_{}_{}.pdf",
-                id, course_code, course_name, year, semester, exam
-            ),
-            PaperCategory::Approved,
-        );
+            .bind(approve_status)
+            .bind(&new_filelink);
 
-        let query = if newly_approved {
-            query.bind(&filelink).bind(username)
+        let query = if approve_status {
+            query.bind(username)
         } else {
             query
         };
 
-        let rows_affected = query.execute(&mut *tx).await?.rows_affected();
-
-        if rows_affected != 1 {
-            tx.rollback().await?;
-
-            return Err(eyre!(
-                "An invalid number of rows were changed: {}",
-                rows_affected
-            ));
-        }
+        let new_qp: DBAdminDashboardQP = query.fetch_one(&mut *tx).await?;
+        let new_qp = AdminDashboardQP::from(new_qp);
 
-        Ok((tx, filelink))
+        Ok((tx, old_filelink, new_qp))
     }
 
     /// Adds a new upload paper's details to the database. Sets the `from_library` field to false.
diff --git a/backend-rs/src/db/queries.rs b/backend-rs/src/db/queries.rs
index 20b0bf1..6d0da6d 100644
--- a/backend-rs/src/db/queries.rs
+++ b/backend-rs/src/db/queries.rs
@@ -49,7 +49,9 @@ pub fn get_get_paper_by_id_query() -> String {
     )
 }
 
-/// Returns a query that updates a paper's details by id ($1) (course_code, course_name, year, semester, exam, approve_status). `filelink` and `approved_by` optionally included if the edit is also used for approval.
+/// Returns a query that updates a paper's details by id ($1) (course_code, course_name, year, semester, exam, approve_status, filelink). `approved_by` optionally included if the edit is also used for approval.
+///
+/// The query also returns all the admin dashboard qp fields of the edited paper
 ///
 /// Query parameters:
 /// - $1: `id`
@@ -63,8 +65,9 @@ pub fn get_get_paper_by_id_query() -> String {
 /// - $9: `approved_by`
 pub fn get_edit_paper_query(approval: bool) -> String {
     format!(
-		"UPDATE iqps set course_code=$2, course_name=$3, year=$4, semester=$5, exam=$6, approve_status=$7{} WHERE id=$1 AND is_deleted=false",
-		if approval {", filelink=$8, approved_by=$9"} else {""}
+		"UPDATE iqps set course_code=$2, course_name=$3, year=$4, semester=$5, exam=$6, approve_status=$7, filelink=$8{} WHERE id=$1 AND is_deleted=false RETURNING {}",
+		if approval {", approved_by=$9"} else {""},
+        ADMIN_DASHBOARD_QP_FIELDS
 	)
 }
 
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index d4b4f8c..0cc9edf 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -15,9 +15,8 @@ use serde::Deserialize;
 
 use crate::{
     auth,
-    db::EditDetails,
     pathutils::PaperCategory,
-    qp::{self, AdminDashboardQP, Exam, Semester},
+    qp::{self, AdminDashboardQP},
 };
 
 use super::{AppError, BackendResponse, RouterState, Status};
@@ -143,65 +142,26 @@ pub async fn edit(
     State(state): State<RouterState>,
     Json(body): Json<EditReq>,
 ) -> HandlerReturn<AdminDashboardQP> {
-    let EditReq {
-        id,
-        course_code,
-        course_name,
-        year,
-        semester,
-        exam,
-        approve_status,
-    } = body;
     let auth = state.auth.lock().await;
 
     if let Some(auth) = auth.clone() {
-        let current_details = state.db.get_paper_by_id(id).await?;
-        let semester = if let Some(sem_str) = semester {
-            Semester::try_from(&sem_str)?
-        } else {
-            current_details.semester
-        };
-        let exam = if let Some(exam_str) = exam {
-            Exam::try_from(&exam_str)?
-        } else {
-            current_details.exam
-        };
-
-        let newly_approved = !current_details.approve_status && approve_status.unwrap_or(false);
-
         // Edit the database entry
-        let (tx, filelink) = state
+        let (tx, old_filelink, new_qp) = state
             .db
-            .edit_paper(
-                id,
-                EditDetails {
-                    course_code: course_code.unwrap_or(current_details.course_code.clone()),
-                    course_name: course_name.unwrap_or(current_details.course_name.clone()),
-                    year: year.unwrap_or(current_details.year),
-                    semester,
-                    exam,
-                    approve_status: approve_status.unwrap_or(current_details.approve_status),
-                },
-                newly_approved,
-                &auth.username,
-                &state.env_vars,
-            )
+            .edit_paper(body, &auth.username, &state.env_vars)
             .await?;
 
         // Copy the actual file
-        let old_filepath = current_details.get_paper_path(&state.env_vars);
-        let new_filepath = state.env_vars.paths.get_path_from_slug(&filelink);
+        let old_filepath = state.env_vars.paths.get_path_from_slug(&old_filelink);
+        let new_filepath = state.env_vars.paths.get_path_from_slug(&new_qp.filelink);
 
         if fs::copy(old_filepath, new_filepath).await.is_ok() {
             // Commit the transaction
             tx.commit().await?;
 
-            // Get the new db entry
-            let new_paper = state.db.get_paper_by_id(id).await?;
-
             Ok(BackendResponse::ok(
                 "Successfully updated paper details.".into(),
-                new_paper.with_url(&state.env_vars)?,
+                new_qp.with_url(&state.env_vars)?,
             ))
         } else {
             tx.rollback().await?;
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 162ade5..3428a3e 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -21,7 +21,7 @@ use crate::{
 mod handlers;
 mod middleware;
 
-pub use handlers::FileDetails;
+pub use handlers::{FileDetails, EditReq};
 
 pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
     let state = RouterState {

From b5adab3f3249f239a996fddc5377e311d23bf384 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 17 Oct 2024 01:38:02 +0530
Subject: [PATCH 18/33] docs: added some documentation to the functions

---
 backend-rs/src/auth.rs               |  2 ++
 backend-rs/src/db/mod.rs             |  5 ++++-
 backend-rs/src/db/queries.rs         |  3 +++
 backend-rs/src/env.rs                |  1 +
 backend-rs/src/main.rs               |  2 +-
 backend-rs/src/pathutils.rs          |  5 +++++
 backend-rs/src/routing/handlers.rs   | 11 +++++++++++
 backend-rs/src/routing/middleware.rs |  3 +++
 backend-rs/src/routing/mod.rs        |  1 +
 9 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/backend-rs/src/auth.rs b/backend-rs/src/auth.rs
index d33ddf0..9a004ed 100644
--- a/backend-rs/src/auth.rs
+++ b/backend-rs/src/auth.rs
@@ -10,6 +10,7 @@ use crate::{
     routing::{self, AppError},
 };
 
+/// Verifies whether a JWT is valid and signed with the secret key
 pub async fn verify_token(
     token: &str,
     env_vars: &EnvVars,
@@ -24,6 +25,7 @@ pub async fn verify_token(
     }
 }
 
+/// Generates a JWT with the username (for claims) and secret key
 async fn generate_token(username: &str, env_vars: &EnvVars) -> Result<String, routing::AppError> {
     let jwt_key = env_vars.get_jwt_key()?;
 
diff --git a/backend-rs/src/db/mod.rs b/backend-rs/src/db/mod.rs
index 479ab17..62b1316 100644
--- a/backend-rs/src/db/mod.rs
+++ b/backend-rs/src/db/mod.rs
@@ -24,7 +24,7 @@ struct Breh {
 }
 
 impl Database {
-    pub async fn try_new(env_vars: &EnvVars) -> Result<Self, sqlx::Error> {
+    pub async fn new(env_vars: &EnvVars) -> Result<Self, sqlx::Error> {
         let database_url = format!(
             "postgres://{}:{}@{}:{}/{}",
             env_vars.db_user,
@@ -45,6 +45,7 @@ impl Database {
         })
     }
 
+    /// Fetches the list of all unapproved papers
     pub async fn get_unapproved_papers(&self) -> Result<Vec<qp::AdminDashboardQP>, sqlx::Error> {
         let query_sql = queries::get_all_unapproved_query();
         let papers: Vec<models::DBAdminDashboardQP> = sqlx::query_as(&query_sql)
@@ -57,6 +58,7 @@ impl Database {
             .collect())
     }
 
+    /// Searches for papers from a given query. Uses some voodoo black magic by @rajivharlalka
     pub async fn search_papers(
         &self,
         query: &String,
@@ -209,6 +211,7 @@ impl Database {
         }
     }
 
+    /// Returns all papers that match one or more of the specified properties exactly. `course_name` is required, other properties are optional.
     pub async fn get_similar_papers(
         &self,
         course_code: &str,
diff --git a/backend-rs/src/db/queries.rs b/backend-rs/src/db/queries.rs
index 6d0da6d..7eb12c1 100644
--- a/backend-rs/src/db/queries.rs
+++ b/backend-rs/src/db/queries.rs
@@ -127,6 +127,9 @@ coalesce(1.0 / (50 + partial_search.rank_ix), 0.0) * 1
 desc
 )";
 
+/// Returns the query for searching question papers. It is mostly voodoo, @Rajiv please update the documentation.
+///
+/// Optionally, the `exam` argument can be used to also add a clause to match the exam field.
 pub fn get_qp_search_query(exam: bool) -> String {
     let mut query = QP_SEARCH.to_owned();
 
diff --git a/backend-rs/src/env.rs b/backend-rs/src/env.rs
index d40b02d..0929009 100644
--- a/backend-rs/src/env.rs
+++ b/backend-rs/src/env.rs
@@ -78,6 +78,7 @@ pub struct EnvVars {
     pub cors_allowed_origins: String,
 
     #[arg(skip)]
+    /// All paths must be handled using this
     pub paths: Paths,
 }
 
diff --git a/backend-rs/src/main.rs b/backend-rs/src/main.rs
index 3c6cee7..598c14e 100644
--- a/backend-rs/src/main.rs
+++ b/backend-rs/src/main.rs
@@ -39,7 +39,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     tracing::subscriber::set_global_default(subscriber)?;
 
     // Database connection
-    let database = db::Database::try_new(&env_vars).await?;
+    let database = db::Database::new(&env_vars).await?;
 
     // Server
     let listener =
diff --git a/backend-rs/src/pathutils.rs b/backend-rs/src/pathutils.rs
index 7a70376..d9091d7 100644
--- a/backend-rs/src/pathutils.rs
+++ b/backend-rs/src/pathutils.rs
@@ -82,6 +82,7 @@ impl Paths {
         })
     }
 
+    /// Returns the slug for a given filename and paper category (directory)
     pub fn get_slug(&self, filename: &str, category: PaperCategory) -> String {
         self.path_slugs
             .get(category)
@@ -90,14 +91,17 @@ impl Paths {
             .to_string()
     }
 
+    /// Returns the absolute system path for the specified directory and filename
     pub fn get_path(&self, filename: &str, dir: PaperCategory) -> PathBuf {
         self.system_paths.get(dir).join(filename)
     }
 
+    /// Returns the absolute system path from a given slug
     pub fn get_path_from_slug(&self, slug: &str) -> PathBuf {
         self.static_files_path.join(slug)
     }
 
+    /// Returns the static server URL for the specified directory and filename
     pub fn get_url(
         &self,
         filename: &str,
@@ -113,6 +117,7 @@ impl Paths {
         self.get_url_from_slug(&slug)
     }
 
+    /// Returns the static server URL for a given slug
     pub fn get_url_from_slug(&self, slug: &str) -> Result<String, color_eyre::eyre::Error> {
         Ok(self.static_files_url.join(slug)?.as_str().to_string())
     }
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index 0cc9edf..26c44b9 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -28,6 +28,7 @@ pub async fn healthcheck() -> HandlerReturn<()> {
     Ok(BackendResponse::ok("Hello, World.".into(), ()))
 }
 
+/// Fetches all the unapproved papers.
 pub async fn get_unapproved(
     State(state): State<RouterState>,
 ) -> HandlerReturn<Vec<AdminDashboardQP>> {
@@ -44,6 +45,7 @@ pub async fn get_unapproved(
     ))
 }
 
+/// Searches for question papers given a query and an optional `exam` parameter.
 pub async fn search(
     State(state): State<RouterState>,
     Query(params): Query<HashMap<String, String>>,
@@ -84,6 +86,8 @@ pub struct OAuthReq {
 pub struct OAuthRes {
     token: String,
 }
+
+/// Takes a Github OAuth code and returns a JWT auth token to log in a user if authorized
 pub async fn oauth(
     State(state): State<RouterState>,
     Json(body): Json<OAuthReq>,
@@ -106,6 +110,8 @@ pub struct ProfileRes {
     token: String,
     username: String,
 }
+
+/// Returns a user's profile (the JWT and username) if authorized and the token is valid. Can be used to check if the user is logged in.
 pub async fn profile(State(state): State<RouterState>) -> HandlerReturn<ProfileRes> {
     let lock = state.auth.lock().await;
 
@@ -196,6 +202,8 @@ pub struct UploadStatus {
     status: Status,
     message: String,
 }
+
+/// Uploads question papers to the server
 pub async fn upload(
     State(state): State<RouterState>,
     mut multipart: Multipart,
@@ -348,6 +356,8 @@ pub async fn upload(
 pub struct DeleteReq {
     id: i32,
 }
+
+/// Deletes a given paper. Library papers cannot be deleted.
 pub async fn delete(
     State(state): State<RouterState>,
     Json(body): Json<DeleteReq>,
@@ -367,6 +377,7 @@ pub async fn delete(
     }
 }
 
+/// Fetches all question papers that match one or more properties specified. `course_name` is compulsory.
 pub async fn similar(
     State(state): State<RouterState>,
     Query(body): Query<HashMap<String, String>>,
diff --git a/backend-rs/src/routing/middleware.rs b/backend-rs/src/routing/middleware.rs
index 8aa82b7..8aec1ea 100644
--- a/backend-rs/src/routing/middleware.rs
+++ b/backend-rs/src/routing/middleware.rs
@@ -9,6 +9,9 @@ use crate::auth;
 
 use super::{AppError, Auth, BackendResponse, RouterState};
 
+/// Verifies the JWT and authenticates a user. If the JWT is invalid, the user is sent an unauthorized status code. If the JWT is valid, the authentication is added to the state.
+///
+/// TODO: THIS IS DUM DUM, CHANGE IT, ADD THE STATE TO THE REQUEST, A SHARED AUTH MUTEX MAKES NO SENSE
 pub async fn verify_jwt_middleware(
     State(state): State<RouterState>,
     headers: HeaderMap,
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 3428a3e..9d22d4b 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -23,6 +23,7 @@ mod middleware;
 
 pub use handlers::{FileDetails, EditReq};
 
+/// Returns the Axum router for IQPS
 pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
     let state = RouterState {
         db,

From bdf86d010635985aa22dcc13aec661e308000a8a Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 17 Oct 2024 01:38:45 +0530
Subject: [PATCH 19/33] feat: cargo fmt

---
 backend-rs/src/routing/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 9d22d4b..616fa07 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -21,7 +21,7 @@ use crate::{
 mod handlers;
 mod middleware;
 
-pub use handlers::{FileDetails, EditReq};
+pub use handlers::{EditReq, FileDetails};
 
 /// Returns the Axum router for IQPS
 pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {

From f9e37c2d735f7c082e48880988630d69dac70fb4 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:09:21 +0530
Subject: [PATCH 20/33] fix: fixed the dum dum, also simplified the code a lot

---
 backend-rs/src/auth.rs               | 21 ++++++--
 backend-rs/src/routing/handlers.rs   | 74 +++++++++++-----------------
 backend-rs/src/routing/middleware.rs | 24 +++------
 backend-rs/src/routing/mod.rs        | 10 ----
 4 files changed, 53 insertions(+), 76 deletions(-)

diff --git a/backend-rs/src/auth.rs b/backend-rs/src/auth.rs
index 9a004ed..1aef9e4 100644
--- a/backend-rs/src/auth.rs
+++ b/backend-rs/src/auth.rs
@@ -10,18 +10,33 @@ use crate::{
     routing::{self, AppError},
 };
 
+#[derive(Clone)]
+pub struct Auth {
+    pub jwt: String,
+    pub username: String,
+}
+
 /// Verifies whether a JWT is valid and signed with the secret key
+///
+/// Returns the username and jwt in a struct
 pub async fn verify_token(
     token: &str,
     env_vars: &EnvVars,
-) -> Result<Option<Claims>, routing::AppError> {
+) -> Result<Auth, color_eyre::eyre::Error> {
     let jwt_key = env_vars.get_jwt_key()?;
     let claims: Result<Claims, _> = token.verify_with_key(&jwt_key);
 
     if let Ok(claims) = claims {
-        Ok(Some(claims))
+        if let Some(username) = claims.private.get("username") {
+            Ok(Auth {
+                jwt: token.to_owned(),
+                username: username.to_string(),
+            })
+        } else {
+            Err(eyre!("Username not in the claims."))
+        }
     } else {
-        Ok(None)
+        Err(eyre!("Claims not found on the JWT."))
     }
 }
 
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index 26c44b9..bbd6454 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -2,6 +2,7 @@ use axum::{
     body::Bytes,
     extract::{Json, Multipart},
     http::StatusCode,
+    Extension,
 };
 use color_eyre::eyre::ContextCompat;
 use http::HeaderMap;
@@ -14,7 +15,7 @@ use axum::extract::{Query, State};
 use serde::Deserialize;
 
 use crate::{
-    auth,
+    auth::{self, Auth},
     pathutils::PaperCategory,
     qp::{self, AdminDashboardQP},
 };
@@ -112,23 +113,14 @@ pub struct ProfileRes {
 }
 
 /// Returns a user's profile (the JWT and username) if authorized and the token is valid. Can be used to check if the user is logged in.
-pub async fn profile(State(state): State<RouterState>) -> HandlerReturn<ProfileRes> {
-    let lock = state.auth.lock().await;
-
-    if let Some(auth) = lock.clone() {
-        Ok(BackendResponse::ok(
-            "Successfully authorized the user.".into(),
-            ProfileRes {
-                token: auth.jwt,
-                username: auth.username,
-            },
-        ))
-    } else {
-        Ok(BackendResponse::error(
-            "Error: User unauthorized.".into(),
-            StatusCode::UNAUTHORIZED,
-        ))
-    }
+pub async fn profile(Extension(auth): Extension<Auth>) -> HandlerReturn<ProfileRes> {
+    Ok(BackendResponse::ok(
+        "Successfully authorized the user.".into(),
+        ProfileRes {
+            token: auth.jwt,
+            username: auth.username,
+        },
+    ))
 }
 
 #[derive(Deserialize)]
@@ -145,41 +137,33 @@ pub struct EditReq {
 /// Takes a JSON request body. The `id` field is required.
 /// Other optional fields can be set to change that particular value in the paper.
 pub async fn edit(
+    Extension(auth): Extension<Auth>,
     State(state): State<RouterState>,
     Json(body): Json<EditReq>,
 ) -> HandlerReturn<AdminDashboardQP> {
-    let auth = state.auth.lock().await;
-
-    if let Some(auth) = auth.clone() {
-        // Edit the database entry
-        let (tx, old_filelink, new_qp) = state
-            .db
-            .edit_paper(body, &auth.username, &state.env_vars)
-            .await?;
+    // Edit the database entry
+    let (tx, old_filelink, new_qp) = state
+        .db
+        .edit_paper(body, &auth.username, &state.env_vars)
+        .await?;
 
-        // Copy the actual file
-        let old_filepath = state.env_vars.paths.get_path_from_slug(&old_filelink);
-        let new_filepath = state.env_vars.paths.get_path_from_slug(&new_qp.filelink);
+    // Copy the actual file
+    let old_filepath = state.env_vars.paths.get_path_from_slug(&old_filelink);
+    let new_filepath = state.env_vars.paths.get_path_from_slug(&new_qp.filelink);
 
-        if fs::copy(old_filepath, new_filepath).await.is_ok() {
-            // Commit the transaction
-            tx.commit().await?;
+    if fs::copy(old_filepath, new_filepath).await.is_ok() {
+        // Commit the transaction
+        tx.commit().await?;
 
-            Ok(BackendResponse::ok(
-                "Successfully updated paper details.".into(),
-                new_qp.with_url(&state.env_vars)?,
-            ))
-        } else {
-            tx.rollback().await?;
-            Ok(BackendResponse::error(
-                "Error copying question paper file.".into(),
-                StatusCode::INTERNAL_SERVER_ERROR,
-            ))
-        }
+        Ok(BackendResponse::ok(
+            "Successfully updated paper details.".into(),
+            new_qp.with_url(&state.env_vars)?,
+        ))
     } else {
+        tx.rollback().await?;
         Ok(BackendResponse::error(
-            "Error getting authenticated user's username.".into(),
-            StatusCode::UNAUTHORIZED,
+            "Error copying question paper file.".into(),
+            StatusCode::INTERNAL_SERVER_ERROR,
         ))
     }
 }
diff --git a/backend-rs/src/routing/middleware.rs b/backend-rs/src/routing/middleware.rs
index 8aec1ea..2ab1db6 100644
--- a/backend-rs/src/routing/middleware.rs
+++ b/backend-rs/src/routing/middleware.rs
@@ -7,7 +7,7 @@ use http::{HeaderMap, StatusCode};
 
 use crate::auth;
 
-use super::{AppError, Auth, BackendResponse, RouterState};
+use super::{AppError, BackendResponse, RouterState};
 
 /// Verifies the JWT and authenticates a user. If the JWT is invalid, the user is sent an unauthorized status code. If the JWT is valid, the authentication is added to the state.
 ///
@@ -15,28 +15,16 @@ use super::{AppError, Auth, BackendResponse, RouterState};
 pub async fn verify_jwt_middleware(
     State(state): State<RouterState>,
     headers: HeaderMap,
-    request: Request,
+    mut request: Request,
     next: Next,
 ) -> Result<Response, AppError> {
     if let Some(auth_header) = headers.get("Authorization") {
         if let Some(jwt) = auth_header.to_str()?.strip_prefix("Bearer ") {
-            let claims = auth::verify_token(jwt, &state.env_vars).await?;
+            let auth = auth::verify_token(jwt, &state.env_vars).await;
 
-            if let Some(claims) = claims {
-                if let Some(username) = claims.private.get("username") {
-                    let mut state_jwt = state.auth.lock().await;
-                    *state_jwt = Auth {
-                        jwt: jwt.to_string(),
-                        username: username.to_string(),
-                    }
-                    .into();
-                } else {
-                    return Ok(BackendResponse::<()>::error(
-                        "Username not found in the claims.".into(),
-                        StatusCode::UNAUTHORIZED,
-                    )
-                    .into_response());
-                }
+            if let Ok(auth) = auth {
+                // If auth is fine, add it to the request extensions
+                request.extensions_mut().insert(auth);
             } else {
                 return Ok(BackendResponse::<()>::error(
                     "Authorization token invalid.".into(),
diff --git a/backend-rs/src/routing/mod.rs b/backend-rs/src/routing/mod.rs
index 616fa07..c3f132a 100644
--- a/backend-rs/src/routing/mod.rs
+++ b/backend-rs/src/routing/mod.rs
@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use axum::{
     extract::{DefaultBodyLimit, Json},
     http::StatusCode,
@@ -7,7 +5,6 @@ use axum::{
 };
 use http::{HeaderValue, Method};
 use serde::Serialize;
-use tokio::sync::Mutex;
 use tower_http::{
     cors::{Any, CorsLayer},
     trace::{self, TraceLayer},
@@ -28,7 +25,6 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
     let state = RouterState {
         db,
         env_vars: env_vars.clone(),
-        auth: Arc::new(Mutex::new(None)),
     };
 
     axum::Router::new()
@@ -72,16 +68,10 @@ pub fn get_router(env_vars: &EnvVars, db: Database) -> axum::Router {
         )
 }
 
-#[derive(Clone)]
-struct Auth {
-    jwt: String,
-    username: String,
-}
 #[derive(Clone)]
 struct RouterState {
     pub db: db::Database,
     pub env_vars: EnvVars,
-    pub auth: Arc<Mutex<Option<Auth>>>,
 }
 
 #[derive(Clone, Copy)]

From 3f99c5afdc4f0fd0785d7cc55b05f5db0b240594 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:12:30 +0530
Subject: [PATCH 21/33] fix: allow unused in some places

---
 backend-rs/src/pathutils.rs | 3 +++
 backend-rs/src/qp.rs        | 6 ------
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/backend-rs/src/pathutils.rs b/backend-rs/src/pathutils.rs
index d9091d7..984316f 100644
--- a/backend-rs/src/pathutils.rs
+++ b/backend-rs/src/pathutils.rs
@@ -3,6 +3,7 @@ use std::path::{self, Path, PathBuf};
 use url::Url;
 
 /// A category of papers, can also be used to represent the directory where these papers are stored
+#[allow(unused)]
 pub enum PaperCategory {
     Unapproved,
     Approved,
@@ -28,6 +29,7 @@ impl PathTriad {
 }
 
 #[derive(Clone)]
+#[allow(unused)]
 pub struct Paths {
     /// URL of the static files server
     static_files_url: Url,
@@ -55,6 +57,7 @@ impl Default for Paths {
     }
 }
 
+#[allow(unused)]
 impl Paths {
     pub fn new(
         static_files_url: &str,
diff --git a/backend-rs/src/qp.rs b/backend-rs/src/qp.rs
index 309b83d..1e123df 100644
--- a/backend-rs/src/qp.rs
+++ b/backend-rs/src/qp.rs
@@ -1,5 +1,3 @@
-use std::path::PathBuf;
-
 use color_eyre::eyre::eyre;
 use duplicate::duplicate_item;
 use serde::Serialize;
@@ -137,8 +135,4 @@ impl QP {
             ..self
         })
     }
-
-    pub fn get_paper_path(&self, env_vars: &EnvVars) -> PathBuf {
-        env_vars.paths.get_path_from_slug(&self.filelink)
-    }
 }

From 9bc5591b40836b8e52b906bfef02b017ce8d935b Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:16:13 +0530
Subject: [PATCH 22/33] feat: ensure existence of system paths

---
 backend-rs/src/pathutils.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/backend-rs/src/pathutils.rs b/backend-rs/src/pathutils.rs
index 984316f..84c7ea9 100644
--- a/backend-rs/src/pathutils.rs
+++ b/backend-rs/src/pathutils.rs
@@ -1,5 +1,6 @@
 use std::path::{self, Path, PathBuf};
 
+use color_eyre::eyre::eyre;
 use url::Url;
 
 /// A category of papers, can also be used to represent the directory where these papers are stored
@@ -77,6 +78,17 @@ impl Paths {
             library: path::absolute(static_file_storage_location.join(&path_slugs.library))?,
         };
 
+        // Ensure these system paths exist
+        if !system_paths.unapproved.exists() {
+            return Err(eyre!("Path for unapproved papers does not exist: {}", system_paths.unapproved.to_string_lossy()));
+        }
+        if !system_paths.approved.exists() {
+            return Err(eyre!("Path for approved papers does not exist: {}", system_paths.approved.to_string_lossy()));
+        }
+        if !system_paths.library.exists() {
+            return Err(eyre!("Path for library papers does not exist: {}", system_paths.library.to_string_lossy()));
+        }
+
         Ok(Self {
             static_files_url: Url::parse(static_files_url)?,
             static_files_path: path::absolute(static_file_storage_location)?,

From 713896da12ed32ebdbaa98bf8564adfd9e7471fa Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:26:03 +0530
Subject: [PATCH 23/33] feat: edit details

---
 frontend/src/components/Common/PaperEditModal.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/frontend/src/components/Common/PaperEditModal.tsx b/frontend/src/components/Common/PaperEditModal.tsx
index 202f151..df8fc3a 100644
--- a/frontend/src/components/Common/PaperEditModal.tsx
+++ b/frontend/src/components/Common/PaperEditModal.tsx
@@ -280,7 +280,7 @@ function PaperEditModal<T extends IQuestionPaperFile | IAdminDashboardQP>(props:
 						disabled={!isDataValid}
 						className={`save-btn ${!isDataValid ? 'disabled' : ''}`}
 					>
-						{'approve_status' in data ? 'Approve' : 'Save'}
+						{'approve_status' in data ? 'Edit Details' : 'Save'}
 					</button>
 				</div>
 			</form>

From 671b1b54037d07a971b7025bd9f441883f063395 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:28:28 +0530
Subject: [PATCH 24/33] fix: changed course -> query

---
 frontend/src/components/Search/SearchForm.tsx | 22 +++++++++++--------
 frontend/src/types/backend.ts                 |  2 +-
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/frontend/src/components/Search/SearchForm.tsx b/frontend/src/components/Search/SearchForm.tsx
index e1c7fbf..053db11 100644
--- a/frontend/src/components/Search/SearchForm.tsx
+++ b/frontend/src/components/Search/SearchForm.tsx
@@ -12,7 +12,11 @@ import { Select } from "../Common/Form";
 function CourseSearchForm() {
 	const currentURL = new URL(window.location.toString());
 
-	const [query, setQuery] = useState<string>(currentURL.searchParams.get('query') ?? '');
+	const [query, setQuery] = useState<string>(
+		currentURL.searchParams.get('query') ??
+		currentURL.searchParams.get('course') ?? // `course` was previously used, keeping for backwards compatibility
+		''
+	);
 	const [exam, setExam] = useState<Exam | ''>(currentURL.searchParams.get('exam') as Exam ?? '');
 
 	const [searchResults, setSearchResults] = useState<ISearchResult[]>([]);
@@ -27,11 +31,11 @@ function CourseSearchForm() {
 			const params = new URLSearchParams();
 			if (query === '') return;
 
-			params.append("course", query);
+			params.append("query", query);
 			params.append("exam", exam);
 
 			setAwaitingResponse(true);
-			const response = await makeRequest('search', 'get', {course: query, exam});
+			const response = await makeRequest('search', 'get', { query, exam });
 
 			if (response.status === 'success') {
 				const data: ISearchResult[] = response.data;
@@ -80,7 +84,7 @@ function CourseSearchForm() {
 	return <div className="search-form">
 		<form onSubmit={handleSubmit}>
 			<div>
-				<label htmlFor="course">Course Name:</label>
+				<label htmlFor="course">Course Name or Code:</label>
 				<input ref={courseInputRef} autoFocus={true} id="course" value={query} onInput={() => setQuery(courseInputRef.current?.value ?? '')} />
 			</div>
 			<div>
@@ -88,11 +92,11 @@ function CourseSearchForm() {
 				<Select
 					id="exam"
 					options={[
-						{value: '', title: 'Mid / End Semester / Class Test'},
-						{value: 'midend', title: 'Mid / End Semester'},
-						{value: 'midsem', title: 'Mid Semester'},
-						{value: 'endsem', title: 'End Semester'},
-						{value: 'ct', title: 'Class Test'}
+						{ value: '', title: 'Mid / End Semester / Class Test' },
+						{ value: 'midend', title: 'Mid / End Semester' },
+						{ value: 'midsem', title: 'Mid Semester' },
+						{ value: 'endsem', title: 'End Semester' },
+						{ value: 'ct', title: 'Class Test' }
 					]}
 					value={exam}
 					onInput={(e) => setExam(e.currentTarget.value as Exam)}
diff --git a/frontend/src/types/backend.ts b/frontend/src/types/backend.ts
index 3f3c09e..0401fe9 100644
--- a/frontend/src/types/backend.ts
+++ b/frontend/src/types/backend.ts
@@ -21,7 +21,7 @@ export type BackendResponse<T> = IOkResponse<T> | IErrorResponse;
 export interface IEndpointTypes {
 	search: {
 		request: {
-			course: string;
+			query: string;
 			exam: Exam | "";
 		},
 		response: ISearchResult[]

From 1a1d0aaf5faaec22d3b5274cb74391d5cca8f20f Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:29:58 +0530
Subject: [PATCH 25/33] feat: ensure creation of paths in a better way

---
 backend-rs/src/pathutils.rs | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/backend-rs/src/pathutils.rs b/backend-rs/src/pathutils.rs
index 84c7ea9..a8c0264 100644
--- a/backend-rs/src/pathutils.rs
+++ b/backend-rs/src/pathutils.rs
@@ -1,4 +1,4 @@
-use std::path::{self, Path, PathBuf};
+use std::{fs, path::{self, Path, PathBuf}};
 
 use color_eyre::eyre::eyre;
 use url::Url;
@@ -79,14 +79,28 @@ impl Paths {
         };
 
         // Ensure these system paths exist
+
+        // Throw error for uploaded and library paths
+        if !path::absolute(static_file_storage_location.join(uploaded_qps_relative_path))?.exists()
+        {
+            return Err(eyre!(
+                "Path for uploaded papers does not exist: {}",
+                system_paths.unapproved.to_string_lossy()
+            ));
+        }
+        if !system_paths.library.exists() {
+            return Err(eyre!(
+                "Path for library papers does not exist: {}",
+                system_paths.library.to_string_lossy()
+            ));
+        }
+
+        // Create dirs for unapproved and approved
         if !system_paths.unapproved.exists() {
-            return Err(eyre!("Path for unapproved papers does not exist: {}", system_paths.unapproved.to_string_lossy()));
+            fs::create_dir(&system_paths.unapproved)?;
         }
         if !system_paths.approved.exists() {
-            return Err(eyre!("Path for approved papers does not exist: {}", system_paths.approved.to_string_lossy()));
-        }
-        if !system_paths.library.exists() {
-            return Err(eyre!("Path for library papers does not exist: {}", system_paths.library.to_string_lossy()));
+            fs::create_dir(&system_paths.approved)?;
         }
 
         Ok(Self {

From fde4476673d3ece60bc6ecabdfe82d44c9f62522 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:36:04 +0530
Subject: [PATCH 26/33] fix: parse string instead

---
 backend-rs/src/auth.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/backend-rs/src/auth.rs b/backend-rs/src/auth.rs
index 1aef9e4..9890f71 100644
--- a/backend-rs/src/auth.rs
+++ b/backend-rs/src/auth.rs
@@ -28,10 +28,14 @@ pub async fn verify_token(
 
     if let Ok(claims) = claims {
         if let Some(username) = claims.private.get("username") {
-            Ok(Auth {
-                jwt: token.to_owned(),
-                username: username.to_string(),
-            })
+            if let Some(username) = username.as_str() {
+                Ok(Auth {
+                    jwt: token.to_owned(),
+                    username: username.to_owned(),
+                })
+            } else {
+                Err(eyre!("Username is not a string."))
+            }
         } else {
             Err(eyre!("Username not in the claims."))
         }

From c7084c51c84be4a524db0e816468cb7509edeb95 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:38:51 +0530
Subject: [PATCH 27/33] feat: allow editing (but not deleting) of approved
 papers from admin dashboard

---
 frontend/src/components/AdminDashboard/QPCard.tsx | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/frontend/src/components/AdminDashboard/QPCard.tsx b/frontend/src/components/AdminDashboard/QPCard.tsx
index 08939af..67e52b8 100644
--- a/frontend/src/components/AdminDashboard/QPCard.tsx
+++ b/frontend/src/components/AdminDashboard/QPCard.tsx
@@ -81,13 +81,13 @@ export function QPCard({ qPaper, onEdit, onDelete, hasOcr }: IQPCardProps) {
                 >
                     <FaFilePdf size="1.5rem" />
                 </a>
+                {
+                    onEdit !== undefined &&
+                    <button onClick={onEdit} className="edit-btn btn">
+                        <FaRegPenToSquare size="1.5rem" />
+                    </button>
+                }
                 {!qPaper.approve_status && <>
-                    {
-                        onEdit !== undefined &&
-                        <button onClick={onEdit} className="edit-btn btn">
-                            <FaRegPenToSquare size="1.5rem" />
-                        </button>
-                    }
                     {
                         onDelete !== undefined &&
                         <button

From 2241760a745f45d22beeb5615324cbbf3fd4cad2 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Fri, 18 Oct 2024 00:50:43 +0530
Subject: [PATCH 28/33] fix: fixed the unknown handling in exam and semester,
 fixed search

---
 backend-rs/src/auth.rs             | 18 +++++++++---------
 backend-rs/src/db/mod.rs           |  9 ++++++---
 backend-rs/src/qp.rs               |  4 ++--
 backend-rs/src/routing/handlers.rs |  2 +-
 4 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/backend-rs/src/auth.rs b/backend-rs/src/auth.rs
index 9890f71..21af7da 100644
--- a/backend-rs/src/auth.rs
+++ b/backend-rs/src/auth.rs
@@ -5,10 +5,7 @@ use http::StatusCode;
 use jwt::{Claims, RegisteredClaims, SignWithKey, VerifyWithKey};
 use serde::Deserialize;
 
-use crate::{
-    env::EnvVars,
-    routing::{self, AppError},
-};
+use crate::env::EnvVars;
 
 #[derive(Clone)]
 pub struct Auth {
@@ -45,7 +42,10 @@ pub async fn verify_token(
 }
 
 /// Generates a JWT with the username (for claims) and secret key
-async fn generate_token(username: &str, env_vars: &EnvVars) -> Result<String, routing::AppError> {
+async fn generate_token(
+    username: &str,
+    env_vars: &EnvVars,
+) -> Result<String, color_eyre::eyre::Error> {
     let jwt_key = env_vars.get_jwt_key()?;
 
     let expiration = chrono::Utc::now()
@@ -100,7 +100,7 @@ struct GithubMembershipResponse {
 pub async fn authenticate_user(
     code: &String,
     env_vars: &EnvVars,
-) -> Result<Option<String>, routing::AppError> {
+) -> Result<Option<String>, color_eyre::eyre::Error> {
     let client = reqwest::Client::new();
 
     // Get the access token for authenticating other endpoints
@@ -120,7 +120,7 @@ pub async fn authenticate_user(
             response.text().await?
         );
 
-        return Err(eyre!("Github API response error.")).map_err(AppError::from);
+        return Err(eyre!("Github API response error."));
     }
 
     let access_token =
@@ -143,7 +143,7 @@ pub async fn authenticate_user(
             response.text().await?
         );
 
-        return Err(eyre!("Github API response error.")).map_err(AppError::from);
+        return Err(eyre!("Github API response error."));
     }
 
     let username = serde_json::from_slice::<GithubUserResponse>(&response.bytes().await?)
@@ -176,7 +176,7 @@ pub async fn authenticate_user(
             response.text().await?
         );
 
-        return Err(eyre!("Github API response error.")).map_err(AppError::from);
+        return Err(eyre!("Github API response error."));
     }
 
     let state = serde_json::from_slice::<GithubMembershipResponse>(&response.bytes().await?)
diff --git a/backend-rs/src/db/mod.rs b/backend-rs/src/db/mod.rs
index 62b1316..892fedf 100644
--- a/backend-rs/src/db/mod.rs
+++ b/backend-rs/src/db/mod.rs
@@ -64,11 +64,14 @@ impl Database {
         query: &String,
         exam: Option<Exam>,
     ) -> Result<Vec<qp::SearchQP>, sqlx::Error> {
-        let query_sql = queries::get_qp_search_query(exam.is_some());
+        let exam_param = exam.map(String::from).unwrap_or("".into());
+        let use_exam = !exam_param.is_empty();
+
+        let query_sql = queries::get_qp_search_query(use_exam);
         let query = sqlx::query_as(&query_sql).bind(query);
 
-        let query = if let Some(exam) = exam {
-            query.bind(String::from(exam))
+        let query = if use_exam {
+            query.bind(exam_param)
         } else {
             query
         };
diff --git a/backend-rs/src/qp.rs b/backend-rs/src/qp.rs
index 1e123df..42769b3 100644
--- a/backend-rs/src/qp.rs
+++ b/backend-rs/src/qp.rs
@@ -32,7 +32,7 @@ impl From<Semester> for String {
         match value {
             Semester::Autumn => "autumn".into(),
             Semester::Spring => "spring".into(),
-            Semester::Unknown => "unknown".into(),
+            Semester::Unknown => "".into(),
         }
     }
 }
@@ -76,7 +76,7 @@ impl From<Exam> for String {
         match value {
             Exam::Midsem => "midsem".into(),
             Exam::Endsem => "endsem".into(),
-            Exam::Unknown => "unknown".into(),
+            Exam::Unknown => "".into(),
             Exam::CT(None) => "ct".into(),
             Exam::CT(Some(i)) => format!("ct{}", i),
         }
diff --git a/backend-rs/src/routing/handlers.rs b/backend-rs/src/routing/handlers.rs
index bbd6454..f456771 100644
--- a/backend-rs/src/routing/handlers.rs
+++ b/backend-rs/src/routing/handlers.rs
@@ -53,7 +53,7 @@ pub async fn search(
 ) -> HandlerReturn<Vec<qp::SearchQP>> {
     let response = if let Some(query) = params.get("query") {
         let exam: Option<qp::Exam> = if let Some(exam_str) = params.get("exam") {
-            Some(qp::Exam::try_from(exam_str).map_err(AppError::from)?)
+            Some(qp::Exam::try_from(exam_str)?)
         } else {
             None
         };

From 1c7b73b351986a7e915b61cde1456c8e4096a2e1 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 24 Oct 2024 13:27:38 +0530
Subject: [PATCH 29/33] feat: move to rustls from native-tls

---
 backend-rs/Cargo.lock | 290 +++++++++++-------------------------------
 backend-rs/Cargo.toml |   2 +-
 2 files changed, 75 insertions(+), 217 deletions(-)

diff --git a/backend-rs/Cargo.lock b/backend-rs/Cargo.lock
index 3b04350..1dc4e61 100644
--- a/backend-rs/Cargo.lock
+++ b/backend-rs/Cargo.lock
@@ -119,12 +119,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "atomic-waker"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
-
 [[package]]
 name = "autocfg"
 version = "1.4.0"
@@ -373,16 +367,6 @@ version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
 
-[[package]]
-name = "core-foundation"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -585,21 +569,6 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared",
-]
-
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
 [[package]]
 name = "form_urlencoded"
 version = "1.2.1"
@@ -708,25 +677,6 @@ version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 
-[[package]]
-name = "h2"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205"
-dependencies = [
- "atomic-waker",
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "http",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
 [[package]]
 name = "hashbrown"
 version = "0.14.5"
@@ -852,7 +802,6 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "h2",
  "http",
  "http-body",
  "httparse",
@@ -879,22 +828,7 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
-]
-
-[[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes",
- "http-body-util",
- "hyper",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
+ "webpki-roots",
 ]
 
 [[package]]
@@ -1159,23 +1093,6 @@ dependencies = [
  "version_check",
 ]
 
-[[package]]
-name = "native-tls"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
-dependencies = [
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
-]
-
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -1264,50 +1181,6 @@ version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
-[[package]]
-name = "openssl"
-version = "0.10.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1"
-dependencies = [
- "bitflags",
- "cfg-if",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
-]
-
-[[package]]
-name = "openssl-macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "openssl-probe"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -1446,6 +1319,52 @@ dependencies = [
  "yansi",
 ]
 
+[[package]]
+name = "quinn"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4ceeeeabace7857413798eb1ffa1e9c905a9946a57d81fb69b4b71c4d8eb3ad"
+dependencies = [
+ "bytes",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "thiserror",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddf517c03a109db8100448a4be38d498df8a210a99fe0e1b9eaf39e78c640efe"
+dependencies = [
+ "bytes",
+ "rand",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "slab",
+ "thiserror",
+ "tinyvec",
+ "tracing",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fe68c2e9e1a1234e218683dbdf9f9dfcb094113c5ac2b938dfcb9bab4c4140b"
+dependencies = [
+ "libc",
+ "once_cell",
+ "socket2",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.37"
@@ -1502,38 +1421,37 @@ checksum = "f713147fbe92361e52392c73b8c9e48c04c6625bce969ef54dc901e58e042a7b"
 dependencies = [
  "base64 0.22.1",
  "bytes",
- "encoding_rs",
  "futures-core",
  "futures-util",
- "h2",
  "http",
  "http-body",
  "http-body-util",
  "hyper",
  "hyper-rustls",
- "hyper-tls",
  "hyper-util",
  "ipnet",
  "js-sys",
  "log",
  "mime",
- "native-tls",
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
+ "quinn",
+ "rustls",
  "rustls-pemfile",
+ "rustls-pki-types",
  "serde",
  "serde_json",
  "serde_urlencoded",
  "sync_wrapper 1.0.1",
- "system-configuration",
  "tokio",
- "tokio-native-tls",
+ "tokio-rustls",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
+ "webpki-roots",
  "windows-registry",
 ]
 
@@ -1578,6 +1496,12 @@ version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
 [[package]]
 name = "rustix"
 version = "0.38.37"
@@ -1593,11 +1517,12 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.14"
+version = "0.23.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "415d9944693cb90382053259f89fbb077ea730ad7273047ec63b19bc9b160ba8"
+checksum = "5fbb44d7acc4e873d613422379f69f237a1b141928c02f6bc6ccfddddc2d7993"
 dependencies = [
  "once_cell",
+ "ring",
  "rustls-pki-types",
  "rustls-webpki",
  "subtle",
@@ -1615,9 +1540,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e696e35370c65c9c541198af4543ccd580cf17fc25d8e05c5a242b202488c55"
+checksum = "16f1201b3c9a7ee8039bcadc17b7e605e2945b27eee7631788c1bd2b0643674b"
 
 [[package]]
 name = "rustls-webpki"
@@ -1642,44 +1567,12 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
-[[package]]
-name = "schannel"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01227be5826fa0690321a2ba6c5cd57a19cf3f6a09e76973b58e61de6ab9d1c1"
-dependencies = [
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
-[[package]]
-name = "security-framework"
-version = "2.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
-dependencies = [
- "bitflags",
- "core-foundation",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
-]
-
-[[package]]
-name = "security-framework-sys"
-version = "2.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea4a292869320c0272d7bc55a5a6aafaff59b4f63404a003887b679a2e05b4b6"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "serde"
 version = "1.0.210"
@@ -2094,27 +1987,6 @@ dependencies = [
  "futures-core",
 ]
 
-[[package]]
-name = "system-configuration"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
-dependencies = [
- "bitflags",
- "core-foundation",
- "system-configuration-sys",
-]
-
-[[package]]
-name = "system-configuration-sys"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "tempfile"
 version = "3.13.0"
@@ -2233,16 +2105,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.26.0"
@@ -2265,19 +2127,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "tokio-util"
-version = "0.7.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
-dependencies = [
- "bytes",
- "futures-core",
- "futures-sink",
- "pin-project-lite",
- "tokio",
-]
-
 [[package]]
 name = "tower"
 version = "0.5.1"
@@ -2578,14 +2427,23 @@ checksum = "a42f6c679374623f295a8623adfe63d9284091245c3504bde47c17a3ce2777d9"
 
 [[package]]
 name = "web-sys"
-version = "0.3.71"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44188d185b5bdcae1052d08bcbcf9091a5524038d4572cc4f4f2bb9d5554ddd9"
+checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-roots"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c452ad30530b54a4d8e71952716a212b08efd0f3562baa66c29a618b07da7c3"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "whoami"
 version = "1.5.2"
diff --git a/backend-rs/Cargo.toml b/backend-rs/Cargo.toml
index c85380a..83bd6a3 100644
--- a/backend-rs/Cargo.toml
+++ b/backend-rs/Cargo.toml
@@ -13,7 +13,7 @@ duplicate = "2.0.0"
 hmac = "0.12.1"
 http = "1.1.0"
 jwt = "0.16.0"
-reqwest = "0.12.8"
+reqwest = { version = "0.12.8", default-features = false, features = ["rustls-tls"] }
 serde = { version = "1.0.210", features = ["serde_derive"] }
 serde_json = "1.0.128"
 sha2 = "0.10.8"

From 0a241cea8ef06e478121a91aeb04822d008a3d5c Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 24 Oct 2024 13:56:51 +0530
Subject: [PATCH 30/33] feat: working Dockerfile with portable binary build

---
 backend-rs/Dockerfile                  | 32 ++++++++++++++++++++++++
 backend-rs/docker-compose.yaml         | 34 ++++++++++++++++++++++++++
 backend-rs/metaploy/iqps.metaploy.conf | 16 ++++++++++++
 backend-rs/metaploy/postinstall.sh     | 14 +++++++++++
 4 files changed, 96 insertions(+)
 create mode 100644 backend-rs/Dockerfile
 create mode 100644 backend-rs/docker-compose.yaml
 create mode 100644 backend-rs/metaploy/iqps.metaploy.conf
 create mode 100644 backend-rs/metaploy/postinstall.sh

diff --git a/backend-rs/Dockerfile b/backend-rs/Dockerfile
new file mode 100644
index 0000000..6394c88
--- /dev/null
+++ b/backend-rs/Dockerfile
@@ -0,0 +1,32 @@
+FROM rust:slim-buster AS builder
+
+WORKDIR /src
+
+# Install dependencies
+RUN apt-get update
+RUN apt-get install -y build-essential musl-dev musl-tools
+
+# Copy all files
+COPY src/ ./src
+COPY metaploy/ ./metaploy
+COPY Cargo.toml Cargo.lock .
+
+# For static build
+RUN rustup target add x86_64-unknown-linux-musl
+RUN cargo build --target=x86_64-unknown-linux-musl --release
+
+FROM alpine:latest AS app
+
+RUN apk --no-cache add tzdata ca-certificates bash
+
+ENV TZ="Asia/Kolkata"
+
+WORKDIR /app
+
+COPY metaploy/ ./
+
+RUN chmod +x ./postinstall.sh
+
+COPY --from=builder /src/target/x86_64-unknown-linux-musl/release/iqps-backend .
+
+CMD ["./postinstall.sh", "./iqps-backend"]
diff --git a/backend-rs/docker-compose.yaml b/backend-rs/docker-compose.yaml
new file mode 100644
index 0000000..6cdcc49
--- /dev/null
+++ b/backend-rs/docker-compose.yaml
@@ -0,0 +1,34 @@
+services:
+  iqps-backend:
+    image: metakgporg/iqps-backend
+    container_name: iqps-backend
+    build: .
+    restart: always
+    env_file:
+      - .env
+    networks:
+      metaploy-network:
+        aliases:
+          - iqps-backend
+      metaploy-private-network:
+    volumes:
+      - ./logs:/var/log/iqps/logs
+      - ./db:/db
+      - nginx-config-volume:/etc/nginx/sites-enabled
+      - odins-vault:/srv/static
+
+networks:
+  metaploy-network:
+    external: true
+    name: metaploy-network
+  metaploy-private-network:
+    external: true
+    name: metaploy-private-network
+
+volumes:
+  nginx-config-volume:
+    external: true
+    name: metaploy-nginx-config-volume
+  odins-vault:
+    external: true
+    name: odins-vault
diff --git a/backend-rs/metaploy/iqps.metaploy.conf b/backend-rs/metaploy/iqps.metaploy.conf
new file mode 100644
index 0000000..aed5571
--- /dev/null
+++ b/backend-rs/metaploy/iqps.metaploy.conf
@@ -0,0 +1,16 @@
+upstream iqps_server {
+	server iqps-backend:5000;
+}
+
+server {
+	server_name iqps-server.metakgp.org;
+
+	location / {
+		proxy_pass http://iqps_server;
+	}
+
+	location /upload {
+		proxy_pass http://iqps_server;
+		client_max_body_size 50m;
+	}
+}
\ No newline at end of file
diff --git a/backend-rs/metaploy/postinstall.sh b/backend-rs/metaploy/postinstall.sh
new file mode 100644
index 0000000..42cdd3d
--- /dev/null
+++ b/backend-rs/metaploy/postinstall.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+
+cleanup() {
+	echo "Container stopped. Removing nginx configuration."
+	rm /etc/nginx/sites-enabled/iqps.metaploy.conf
+}
+
+trap 'cleanup' SIGQUIT SIGTERM SIGHUP
+
+"${@}" &
+
+cp ./iqps.metaploy.conf /etc/nginx/sites-enabled
+
+wait $!

From b061d97bd99a9f69e4ec8bad4804712460690f5a Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 24 Oct 2024 14:00:13 +0530
Subject: [PATCH 31/33] feat: moved the new backend into the backend folder

---
 backend-go-old/.env.template                  | 16 ++++++++++
 backend-go-old/Dockerfile                     | 27 ++++++++++++++++
 {backend => backend-go-old}/courses.csv       |  0
 .../docker-compose.dev.yaml                   |  2 +-
 .../docker-compose.yaml                       |  0
 {backend => backend-go-old}/go.mod            |  0
 {backend => backend-go-old}/go.sum            |  0
 {backend => backend-go-old}/handlers.go       |  0
 {backend => backend-go-old}/main.go           |  0
 .../metaploy/iqps.metaploy.conf               |  0
 .../metaploy/postinstall.sh                   |  0
 .../pkg/config/config.go                      |  0
 {backend => backend-go-old}/pkg/db/db.go      |  0
 {backend => backend-go-old}/pkg/db/query.go   |  0
 {backend => backend-go-old}/pkg/db/search.go  |  0
 .../pkg/models/model.go                       |  0
 {backend => backend-go-old}/pkg/utils/util.go |  0
 {backend => backend-go-old}/search.sql        |  0
 backend-rs/.env.template                      | 25 ---------------
 backend-rs/Dockerfile                         | 32 -------------------
 backend/.env.template                         | 29 +++++++++++------
 {backend-rs => backend}/.gitignore            |  0
 {backend-rs => backend}/Cargo.lock            |  0
 {backend-rs => backend}/Cargo.toml            |  0
 backend/Dockerfile                            | 21 +++++++-----
 backend/docker-compose.dev.yaml               |  2 +-
 {backend-rs => backend}/src/auth.rs           |  0
 {backend-rs => backend}/src/db/mod.rs         |  0
 {backend-rs => backend}/src/db/models.rs      |  0
 {backend-rs => backend}/src/db/queries.rs     |  0
 {backend-rs => backend}/src/env.rs            |  0
 {backend-rs => backend}/src/main.rs           |  0
 {backend-rs => backend}/src/pathutils.rs      |  0
 {backend-rs => backend}/src/qp.rs             |  0
 .../src/routing/handlers.rs                   |  0
 .../src/routing/middleware.rs                 |  0
 {backend-rs => backend}/src/routing/mod.rs    |  0
 37 files changed, 77 insertions(+), 77 deletions(-)
 create mode 100644 backend-go-old/.env.template
 create mode 100644 backend-go-old/Dockerfile
 rename {backend => backend-go-old}/courses.csv (100%)
 rename {backend-rs => backend-go-old}/docker-compose.dev.yaml (81%)
 rename {backend-rs => backend-go-old}/docker-compose.yaml (100%)
 rename {backend => backend-go-old}/go.mod (100%)
 rename {backend => backend-go-old}/go.sum (100%)
 rename {backend => backend-go-old}/handlers.go (100%)
 rename {backend => backend-go-old}/main.go (100%)
 rename {backend-rs => backend-go-old}/metaploy/iqps.metaploy.conf (100%)
 rename {backend-rs => backend-go-old}/metaploy/postinstall.sh (100%)
 rename {backend => backend-go-old}/pkg/config/config.go (100%)
 rename {backend => backend-go-old}/pkg/db/db.go (100%)
 rename {backend => backend-go-old}/pkg/db/query.go (100%)
 rename {backend => backend-go-old}/pkg/db/search.go (100%)
 rename {backend => backend-go-old}/pkg/models/model.go (100%)
 rename {backend => backend-go-old}/pkg/utils/util.go (100%)
 rename {backend => backend-go-old}/search.sql (100%)
 delete mode 100644 backend-rs/.env.template
 delete mode 100644 backend-rs/Dockerfile
 rename {backend-rs => backend}/.gitignore (100%)
 rename {backend-rs => backend}/Cargo.lock (100%)
 rename {backend-rs => backend}/Cargo.toml (100%)
 rename {backend-rs => backend}/src/auth.rs (100%)
 rename {backend-rs => backend}/src/db/mod.rs (100%)
 rename {backend-rs => backend}/src/db/models.rs (100%)
 rename {backend-rs => backend}/src/db/queries.rs (100%)
 rename {backend-rs => backend}/src/env.rs (100%)
 rename {backend-rs => backend}/src/main.rs (100%)
 rename {backend-rs => backend}/src/pathutils.rs (100%)
 rename {backend-rs => backend}/src/qp.rs (100%)
 rename {backend-rs => backend}/src/routing/handlers.rs (100%)
 rename {backend-rs => backend}/src/routing/middleware.rs (100%)
 rename {backend-rs => backend}/src/routing/mod.rs (100%)

diff --git a/backend-go-old/.env.template b/backend-go-old/.env.template
new file mode 100644
index 0000000..6cd54de
--- /dev/null
+++ b/backend-go-old/.env.template
@@ -0,0 +1,16 @@
+STATIC_FILES_URL=https://static.metakgp.org
+DB_NAME=
+DB_HOST=
+DB_PORT=
+DB_USER=
+DB_PASSWORD=
+STATIC_FILES_STORAGE_LOCATION=/srv/static
+UPLOADED_QPS_PATH=iqps/uploaded # Relative to `STATIC_FILES_STORAGE_LOCATION`. Final upload location will be /srv/static/iqps/uploaded
+MAX_UPLOAD_LIMIT=10
+GH_CLIENT_ID= # public token of the oauth app
+GH_PRIVATE_ID= # Private token of the oauth app
+JWT_SECRET= # JWT encryption secret
+GH_ORG_NAME= # name of the org
+GH_ORG_TEAM_SLUG= #URL friendly team Name
+GH_ORG_ADMIN_TOKEN= #GH TOKEN OF AN ORG ADMIN
+IQPS_LOG_LOCATION=./log/application.log
\ No newline at end of file
diff --git a/backend-go-old/Dockerfile b/backend-go-old/Dockerfile
new file mode 100644
index 0000000..3292e35
--- /dev/null
+++ b/backend-go-old/Dockerfile
@@ -0,0 +1,27 @@
+FROM golang:1.22.4 AS builder
+
+WORKDIR /src
+
+COPY go.mod go.sum ./
+
+RUN go mod download
+
+COPY . .
+
+RUN CGO_ENABLED=1 GOOS=linux go build -o ./build --tags "fts5" -a -ldflags '-linkmode external -extldflags "-static"' .
+
+FROM alpine:latest AS app
+
+RUN apk --no-cache add tzdata ca-certificates bash
+
+ENV TZ="Asia/Kolkata"
+
+WORKDIR /app
+
+COPY metaploy/ ./
+
+RUN chmod +x ./postinstall.sh
+
+COPY --from=builder /src/build .
+
+CMD ["./postinstall.sh", "./build"]
diff --git a/backend/courses.csv b/backend-go-old/courses.csv
similarity index 100%
rename from backend/courses.csv
rename to backend-go-old/courses.csv
diff --git a/backend-rs/docker-compose.dev.yaml b/backend-go-old/docker-compose.dev.yaml
similarity index 81%
rename from backend-rs/docker-compose.dev.yaml
rename to backend-go-old/docker-compose.dev.yaml
index edb1628..6ba528a 100644
--- a/backend-rs/docker-compose.dev.yaml
+++ b/backend-go-old/docker-compose.dev.yaml
@@ -9,7 +9,7 @@ services:
       - PGPORT=${DB_PORT}
       - PGHOST=${DB_HOST}
     healthcheck:
-      test: ["CMD", "pg_isready", "-U", "${POSTGRES_USER}", "${POSTGRES_DB}"]
+      test: ["CMD", "pg_isready", "-U", "postgres"]
       interval: 5s
       timeout: 3s
       retries: 20
diff --git a/backend-rs/docker-compose.yaml b/backend-go-old/docker-compose.yaml
similarity index 100%
rename from backend-rs/docker-compose.yaml
rename to backend-go-old/docker-compose.yaml
diff --git a/backend/go.mod b/backend-go-old/go.mod
similarity index 100%
rename from backend/go.mod
rename to backend-go-old/go.mod
diff --git a/backend/go.sum b/backend-go-old/go.sum
similarity index 100%
rename from backend/go.sum
rename to backend-go-old/go.sum
diff --git a/backend/handlers.go b/backend-go-old/handlers.go
similarity index 100%
rename from backend/handlers.go
rename to backend-go-old/handlers.go
diff --git a/backend/main.go b/backend-go-old/main.go
similarity index 100%
rename from backend/main.go
rename to backend-go-old/main.go
diff --git a/backend-rs/metaploy/iqps.metaploy.conf b/backend-go-old/metaploy/iqps.metaploy.conf
similarity index 100%
rename from backend-rs/metaploy/iqps.metaploy.conf
rename to backend-go-old/metaploy/iqps.metaploy.conf
diff --git a/backend-rs/metaploy/postinstall.sh b/backend-go-old/metaploy/postinstall.sh
similarity index 100%
rename from backend-rs/metaploy/postinstall.sh
rename to backend-go-old/metaploy/postinstall.sh
diff --git a/backend/pkg/config/config.go b/backend-go-old/pkg/config/config.go
similarity index 100%
rename from backend/pkg/config/config.go
rename to backend-go-old/pkg/config/config.go
diff --git a/backend/pkg/db/db.go b/backend-go-old/pkg/db/db.go
similarity index 100%
rename from backend/pkg/db/db.go
rename to backend-go-old/pkg/db/db.go
diff --git a/backend/pkg/db/query.go b/backend-go-old/pkg/db/query.go
similarity index 100%
rename from backend/pkg/db/query.go
rename to backend-go-old/pkg/db/query.go
diff --git a/backend/pkg/db/search.go b/backend-go-old/pkg/db/search.go
similarity index 100%
rename from backend/pkg/db/search.go
rename to backend-go-old/pkg/db/search.go
diff --git a/backend/pkg/models/model.go b/backend-go-old/pkg/models/model.go
similarity index 100%
rename from backend/pkg/models/model.go
rename to backend-go-old/pkg/models/model.go
diff --git a/backend/pkg/utils/util.go b/backend-go-old/pkg/utils/util.go
similarity index 100%
rename from backend/pkg/utils/util.go
rename to backend-go-old/pkg/utils/util.go
diff --git a/backend/search.sql b/backend-go-old/search.sql
similarity index 100%
rename from backend/search.sql
rename to backend-go-old/search.sql
diff --git a/backend-rs/.env.template b/backend-rs/.env.template
deleted file mode 100644
index edf19c4..0000000
--- a/backend-rs/.env.template
+++ /dev/null
@@ -1,25 +0,0 @@
-DB_NAME=
-DB_HOST=
-DB_PORT=
-DB_USER=
-DB_PASSWORD=
-
-GH_CLIENT_ID=
-GH_CLIENT_SECRET=
-GH_ORG_NAME=
-GH_ORG_TEAM_SLUG=
-GH_ORG_ADMIN_TOKEN=
-
-JWT_SECRET=
-
-MAX_UPLOAD_LIMIT=10
-LOG_LOCATION=./log/application.log
-
-STATIC_FILES_URL=https://static.metakgp.org
-STATIC_FILE_STORAGE_LOCATION=/srv/static
-UPLOADED_QPS_PATH=iqps/uploaded
-LIBRARY_QPS_PATH=peqp/qp
-
-SERVER_PORT=8080
-
-CORS_ALLOWED_ORIGINS=https://qp.metakgp.org,http://localhost:5173
\ No newline at end of file
diff --git a/backend-rs/Dockerfile b/backend-rs/Dockerfile
deleted file mode 100644
index 6394c88..0000000
--- a/backend-rs/Dockerfile
+++ /dev/null
@@ -1,32 +0,0 @@
-FROM rust:slim-buster AS builder
-
-WORKDIR /src
-
-# Install dependencies
-RUN apt-get update
-RUN apt-get install -y build-essential musl-dev musl-tools
-
-# Copy all files
-COPY src/ ./src
-COPY metaploy/ ./metaploy
-COPY Cargo.toml Cargo.lock .
-
-# For static build
-RUN rustup target add x86_64-unknown-linux-musl
-RUN cargo build --target=x86_64-unknown-linux-musl --release
-
-FROM alpine:latest AS app
-
-RUN apk --no-cache add tzdata ca-certificates bash
-
-ENV TZ="Asia/Kolkata"
-
-WORKDIR /app
-
-COPY metaploy/ ./
-
-RUN chmod +x ./postinstall.sh
-
-COPY --from=builder /src/target/x86_64-unknown-linux-musl/release/iqps-backend .
-
-CMD ["./postinstall.sh", "./iqps-backend"]
diff --git a/backend/.env.template b/backend/.env.template
index 6cd54de..edf19c4 100644
--- a/backend/.env.template
+++ b/backend/.env.template
@@ -1,16 +1,25 @@
-STATIC_FILES_URL=https://static.metakgp.org
 DB_NAME=
 DB_HOST=
 DB_PORT=
 DB_USER=
 DB_PASSWORD=
-STATIC_FILES_STORAGE_LOCATION=/srv/static
-UPLOADED_QPS_PATH=iqps/uploaded # Relative to `STATIC_FILES_STORAGE_LOCATION`. Final upload location will be /srv/static/iqps/uploaded
+
+GH_CLIENT_ID=
+GH_CLIENT_SECRET=
+GH_ORG_NAME=
+GH_ORG_TEAM_SLUG=
+GH_ORG_ADMIN_TOKEN=
+
+JWT_SECRET=
+
 MAX_UPLOAD_LIMIT=10
-GH_CLIENT_ID= # public token of the oauth app
-GH_PRIVATE_ID= # Private token of the oauth app
-JWT_SECRET= # JWT encryption secret
-GH_ORG_NAME= # name of the org
-GH_ORG_TEAM_SLUG= #URL friendly team Name
-GH_ORG_ADMIN_TOKEN= #GH TOKEN OF AN ORG ADMIN
-IQPS_LOG_LOCATION=./log/application.log
\ No newline at end of file
+LOG_LOCATION=./log/application.log
+
+STATIC_FILES_URL=https://static.metakgp.org
+STATIC_FILE_STORAGE_LOCATION=/srv/static
+UPLOADED_QPS_PATH=iqps/uploaded
+LIBRARY_QPS_PATH=peqp/qp
+
+SERVER_PORT=8080
+
+CORS_ALLOWED_ORIGINS=https://qp.metakgp.org,http://localhost:5173
\ No newline at end of file
diff --git a/backend-rs/.gitignore b/backend/.gitignore
similarity index 100%
rename from backend-rs/.gitignore
rename to backend/.gitignore
diff --git a/backend-rs/Cargo.lock b/backend/Cargo.lock
similarity index 100%
rename from backend-rs/Cargo.lock
rename to backend/Cargo.lock
diff --git a/backend-rs/Cargo.toml b/backend/Cargo.toml
similarity index 100%
rename from backend-rs/Cargo.toml
rename to backend/Cargo.toml
diff --git a/backend/Dockerfile b/backend/Dockerfile
index 3292e35..6394c88 100644
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -1,14 +1,19 @@
-FROM golang:1.22.4 AS builder
+FROM rust:slim-buster AS builder
 
 WORKDIR /src
 
-COPY go.mod go.sum ./
+# Install dependencies
+RUN apt-get update
+RUN apt-get install -y build-essential musl-dev musl-tools
 
-RUN go mod download
+# Copy all files
+COPY src/ ./src
+COPY metaploy/ ./metaploy
+COPY Cargo.toml Cargo.lock .
 
-COPY . .
-
-RUN CGO_ENABLED=1 GOOS=linux go build -o ./build --tags "fts5" -a -ldflags '-linkmode external -extldflags "-static"' .
+# For static build
+RUN rustup target add x86_64-unknown-linux-musl
+RUN cargo build --target=x86_64-unknown-linux-musl --release
 
 FROM alpine:latest AS app
 
@@ -22,6 +27,6 @@ COPY metaploy/ ./
 
 RUN chmod +x ./postinstall.sh
 
-COPY --from=builder /src/build .
+COPY --from=builder /src/target/x86_64-unknown-linux-musl/release/iqps-backend .
 
-CMD ["./postinstall.sh", "./build"]
+CMD ["./postinstall.sh", "./iqps-backend"]
diff --git a/backend/docker-compose.dev.yaml b/backend/docker-compose.dev.yaml
index 6ba528a..edb1628 100644
--- a/backend/docker-compose.dev.yaml
+++ b/backend/docker-compose.dev.yaml
@@ -9,7 +9,7 @@ services:
       - PGPORT=${DB_PORT}
       - PGHOST=${DB_HOST}
     healthcheck:
-      test: ["CMD", "pg_isready", "-U", "postgres"]
+      test: ["CMD", "pg_isready", "-U", "${POSTGRES_USER}", "${POSTGRES_DB}"]
       interval: 5s
       timeout: 3s
       retries: 20
diff --git a/backend-rs/src/auth.rs b/backend/src/auth.rs
similarity index 100%
rename from backend-rs/src/auth.rs
rename to backend/src/auth.rs
diff --git a/backend-rs/src/db/mod.rs b/backend/src/db/mod.rs
similarity index 100%
rename from backend-rs/src/db/mod.rs
rename to backend/src/db/mod.rs
diff --git a/backend-rs/src/db/models.rs b/backend/src/db/models.rs
similarity index 100%
rename from backend-rs/src/db/models.rs
rename to backend/src/db/models.rs
diff --git a/backend-rs/src/db/queries.rs b/backend/src/db/queries.rs
similarity index 100%
rename from backend-rs/src/db/queries.rs
rename to backend/src/db/queries.rs
diff --git a/backend-rs/src/env.rs b/backend/src/env.rs
similarity index 100%
rename from backend-rs/src/env.rs
rename to backend/src/env.rs
diff --git a/backend-rs/src/main.rs b/backend/src/main.rs
similarity index 100%
rename from backend-rs/src/main.rs
rename to backend/src/main.rs
diff --git a/backend-rs/src/pathutils.rs b/backend/src/pathutils.rs
similarity index 100%
rename from backend-rs/src/pathutils.rs
rename to backend/src/pathutils.rs
diff --git a/backend-rs/src/qp.rs b/backend/src/qp.rs
similarity index 100%
rename from backend-rs/src/qp.rs
rename to backend/src/qp.rs
diff --git a/backend-rs/src/routing/handlers.rs b/backend/src/routing/handlers.rs
similarity index 100%
rename from backend-rs/src/routing/handlers.rs
rename to backend/src/routing/handlers.rs
diff --git a/backend-rs/src/routing/middleware.rs b/backend/src/routing/middleware.rs
similarity index 100%
rename from backend-rs/src/routing/middleware.rs
rename to backend/src/routing/middleware.rs
diff --git a/backend-rs/src/routing/mod.rs b/backend/src/routing/mod.rs
similarity index 100%
rename from backend-rs/src/routing/mod.rs
rename to backend/src/routing/mod.rs

From 566f1abcf726da13b2c6b7f5f39ee04640bff0f3 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 24 Oct 2024 14:15:15 +0530
Subject: [PATCH 32/33] feat: changed backend port to 8080 in metaploy config

---
 backend/metaploy/iqps.metaploy.conf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/metaploy/iqps.metaploy.conf b/backend/metaploy/iqps.metaploy.conf
index aed5571..29872c7 100644
--- a/backend/metaploy/iqps.metaploy.conf
+++ b/backend/metaploy/iqps.metaploy.conf
@@ -1,5 +1,5 @@
 upstream iqps_server {
-	server iqps-backend:5000;
+	server iqps-backend:8080;
 }
 
 server {

From 729a3e6ca861825ef98d2d41ed9531b3d8f1a394 Mon Sep 17 00:00:00 2001
From: Harsh Khandeparkar <shadowwarriorpro3003@gmail.com>
Date: Thu, 24 Oct 2024 14:17:02 +0530
Subject: [PATCH 33/33] docs: updated readme

---
 README.md | 40 +++++++++++++++++++++++++++++-----------
 1 file changed, 29 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index 9ea63bf..1b7e438 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ IQPS was originally created by [Shubham Mishra](https://github.com/grapheo12) in
     - Make the env file by copying the template: `cp .env.template .env`
     - Fill the env variable and set `DB_HOST=localhost` for running locally for development
     - Start the DB by running `docker compose -f docker-compose.dev.yaml up -d`
-    - Start the Go backend by running `go run .`
+    - Start the Rust backend by running `cargo run .`
 3. Set up the frontend by running `pnpm install` and then `pnpm start` in the `frontend/` directory.
 4. Profit.
 
@@ -77,20 +77,38 @@ IQPS was originally created by [Shubham Mishra](https://github.com/grapheo12) in
 5. Optionally set up a Systemd service to start the wiki on startup or use this [deployment github workflow](./.github/workflows/deploy.yaml).
 
 ### Environment Variables
-Environment variables can be set using a `.env` file. Use the `.env.template` files for reference.
+Environment variables can be set using a `.env` file. Use the `.env.template` files for reference. See `backend/src/env.rs` for more documentation and types.
 
 #### Backend
-- `DB_PATH`: Path to the database file to use.
-- `STATIC_FILES_URL`: The base URL for the static files (PDFs).
-- `QPS_PATH`: The local path on the server to store question paper PDFs.
-- `DB_NAME`: The name for your database.
-- `DB_HOST`: `localhost` if using local postgres server or set your **own** database host address.
-- `DB_PORT`: `5432` if using local postgres server, or set to your **own** database port.
-- `DB_USER`: The access username for database.
-- `DB_PASSWORD`: The access password corressponding to the user.
+##### Database (Postgres)
+- `DB_NAME`: Database name
+- `DB_HOST`: Database hostname (eg: `localhost`)
+- `DB_PORT`: Database port
+- `DB_USER`: Database username
+- `DB_PASSWORD`: Database password
+
+##### Authentication
+- `GH_CLIENT_ID`: Client ID of the Github OAuth app.
+- `GH_CLIENT_SECRET`: Client secret of the Github OAuth app.
+- `GH_ORG_NAME`: The name of the Github organization of the admins.
+- `GH_ORG_TEAM_SLUG`: The URL slug of the Github org team of the admins.
+- `JWT_SECRET`: A secret key/password for JWT signing. It should be a long, random, unguessable string.
+
+##### Configuration
+- `MAX_UPLOAD_LIMIT`: Maximum number of files that can be uploaded at once.
+- `LOG_LOCATION`: The path to a local logfile.
+- `STATIC_FILES_URL`: The URL of the static files server. (eg: `https://static.metakgp.org`)
+- `STATIC_FILE_STORAGE_LOCATION`: The path to the local directory from which the static files are served.
+- `UPLOADED_QPS_PATH`: A path relative to `STATIC_FILE_STORAGE_LOCATION` where the uploaded question papers will be stored. (eg: `iqps/uploaded`)
+- `LIBRARY_QPS_PATH`: A path relative to `STATIC_FILE_STORAGE_LOCATION` where the library question papers are scraped and stored. (eg: `peqp/qp`)
+- `SERVER_PORT`: The port on which the server listens.
+- `CORS_ALLOWED_ORIGINS`: A comma (,) separated list of origins to be allowed in CORS.
 
 #### Frontend
-- `VITE_BACKEND_URL`: The IQPS backend URL. Use `http://localhost:5000` in development.
+- `VITE_BACKEND_URL`: The IQPS backend URL. Use `http://localhost:8080` in development.
+- `VITE_MAX_UPLOAD_LIMIT` The maximum number of files that can be uploaded at once. (Note: This is only a client-side limit)
+- `VITE_GH_OAUTH_CLIENT_ID` The Client ID of the Github OAuth app.
+
 
 ## Contact