refactor:auto-formated code using rustfmt

Author: AadarshM07

src/daily_task/mod.rs

@@ -1,16 +1,16 @@
 use chrono::NaiveTime;
+use crate::graphql::mutations::{
+    fetch_and_update_codeforces_stats, fetch_and_update_leetcode, update_leaderboard_scores,
+};
 use chrono_tz::Asia::Kolkata;
 use sqlx::PgPool;
 use std::sync::Arc;
 use tokio::time::sleep_until;
 use tracing::{debug, error, info};
-use crate::graphql::mutations::{fetch_and_update_codeforces_stats,fetch_and_update_leetcode,update_leaderboard_scores};
 
-use crate::{
-    models::{
-        leaderboard::{CodeforcesStats, LeetCodeStats},
-        member::Member,
-    },
+use crate::models::{
+    leaderboard::{CodeforcesStats, LeetCodeStats},
+    member::Member,
 };
 
 pub async fn run_daily_task_at_midnight(pool: Arc<PgPool>) {
@@ -88,10 +88,13 @@ pub async fn update_leaderboard_task(pool: Arc<PgPool>) {
                     let username = leetcode_stats.leetcode_username.clone();
 
                     // Fetch and update LeetCode stats
-                    match fetch_and_update_leetcode(pool.clone(), member.member_id, &username).await {
-                        Ok(_) => println!("LeetCode stats updated for member ID: {}", member.member_id),
+                    match fetch_and_update_leetcode(pool.clone(), member.member_id, &username).await
+                    {
+                        Ok(_) => {
+                            println!("LeetCode stats updated for member ID: {}", member.member_id)
+                        }
                         Err(e) => eprintln!(
-                            "Failed to update LeetCode stats for member ID {}: {:?}", 
+                            "Failed to update LeetCode stats for member ID {}: {:?}",
                             member.member_id, e
                         ),
                     }
@@ -109,11 +112,19 @@ pub async fn update_leaderboard_task(pool: Arc<PgPool>) {
                     let username = codeforces_stats.codeforces_handle.clone();
 
                     // Fetch and update Codeforces stats
-                    match fetch_and_update_codeforces_stats(pool.clone(), member.member_id, &username).await
+                    match fetch_and_update_codeforces_stats(
+                        pool.clone(),
+                        member.member_id,
+                        &username,
+                    )
+                    .await
                     {
-                        Ok(_) => println!("Codeforces stats updated for member ID: {}", member.member_id),
+                        Ok(_) => println!(
+                            "Codeforces stats updated for member ID: {}",
+                            member.member_id
+                        ),
                         Err(e) => eprintln!(
-                            "Failed to update Codeforces stats for member ID {}: {:?}", 
+                            "Failed to update Codeforces stats for member ID {}: {:?}",
                             member.member_id, e
                         ),
                     }
@@ -130,8 +141,6 @@ pub async fn update_leaderboard_task(pool: Arc<PgPool>) {
     }
 }
 
-
-
 async fn update_attendance(members: Vec<Member>, pool: &PgPool) {
     #[allow(deprecated)]
     let today = chrono::Utc::now()
@@ -208,4 +217,4 @@ async fn update_status_history(members: &Vec<Member>, pool: &PgPool) {
             }
         }
     }
-}
+}

src/graphql/mod.rs

@@ -1,6 +1,11 @@
 use async_graphql::MergedObject;
-use mutations::{AttendanceMutations, MemberMutations, ProjectMutations, StreakMutations,FetchLeetCode,FetchCodeForces,LeaderboardMutation};
-use queries::{AttendanceQueries, MemberQueries, ProjectQueries, StreakQueries, LeaderboardQueries};
+use mutations::{
+    AttendanceMutations, FetchCodeForces, FetchLeetCode, LeaderboardMutation, MemberMutations,
+    ProjectMutations, StreakMutations,
+};
+use queries::{
+    AttendanceQueries, LeaderboardQueries, MemberQueries, ProjectQueries, StreakQueries,
+};
 
 pub mod mutations;
 pub mod queries;
@@ -23,5 +28,4 @@ pub struct Mutation(
     FetchLeetCode,
     FetchCodeForces,
     LeaderboardMutation,
-
 );

src/graphql/mutations/codeforces_status.rs

@@ -1,7 +1,7 @@
+use super::leaderboard_api::fetch_and_update_codeforces_stats;
 use async_graphql::{Context, Object, Result};
 use sqlx::PgPool;
 use std::sync::Arc;
-use super::leaderboard_api::fetch_and_update_codeforces_stats;
 
 #[derive(Default)]
 pub struct FetchCodeForces;

src/graphql/mutations/leaderboard_api.rs

@@ -1,16 +1,15 @@
 use reqwest;
+use reqwest::Client;
 use serde_json::Value;
 use sqlx::PgPool;
-use std::sync::Arc;
 use std::collections::HashMap;
-use reqwest::Client;
-
+use std::sync::Arc;
 
 pub async fn fetch_and_update_codeforces_stats(
     pool: Arc<PgPool>,
     member_id: i32,
     username: &str,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync>>{
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let url = format!("https://codeforces.com/api/user.rating?handle={}", username);
     let response = reqwest::get(&url).await?.text().await?;
     let data: Value = serde_json::from_str(&response)?;
@@ -87,7 +86,11 @@ pub async fn update_leaderboard_scores(pool: Arc<PgPool>) -> Result<(), sqlx::Er
         .map(|row| {
             (
                 row.member_id,
-                (row.codeforces_rating, row.max_rating, row.contests_participated),
+                (
+                    row.codeforces_rating,
+                    row.max_rating,
+                    row.contests_participated,
+                ),
             )
         })
         .collect();
@@ -99,7 +102,8 @@ pub async fn update_leaderboard_scores(pool: Arc<PgPool>) -> Result<(), sqlx::Er
             + (2 * row.contests_participated)
             + (100 - row.best_rank / 10).max(0);
 
-        let (codeforces_score, unified_score) = cf_lookup.get(&row.member_id)
+        let (codeforces_score, unified_score) = cf_lookup
+            .get(&row.member_id)
             .map(|(rating, max_rating, contests)| {
                 let cf_score = (rating / 10) + (max_rating / 20) + (5 * contests);
                 (cf_score, leetcode_score + cf_score)
@@ -123,18 +127,23 @@ pub async fn update_leaderboard_scores(pool: Arc<PgPool>) -> Result<(), sqlx::Er
         .await;
 
         if let Err(e) = result {
-            eprintln!("Failed to update leaderboard for member ID {}: {:?}", row.member_id, e);
+            eprintln!(
+                "Failed to update leaderboard for member ID {}: {:?}",
+                row.member_id, e
+            );
         }
     }
 
     for row in &codeforces_stats {
-        if leetcode_stats.iter().any(|lc| lc.member_id == row.member_id) {
+        if leetcode_stats
+            .iter()
+            .any(|lc| lc.member_id == row.member_id)
+        {
             continue;
         }
 
-        let codeforces_score = (row.codeforces_rating / 10)
-            + (row.max_rating / 20)
-            + (5 * row.contests_participated);
+        let codeforces_score =
+            (row.codeforces_rating / 10) + (row.max_rating / 20) + (5 * row.contests_participated);
 
         let unified_score = codeforces_score;
 
@@ -155,15 +164,16 @@ pub async fn update_leaderboard_scores(pool: Arc<PgPool>) -> Result<(), sqlx::Er
         .await;
 
         if let Err(e) = result {
-            eprintln!("Failed to update leaderboard for Codeforces-only member ID {}: {:?}", row.member_id, e);
+            eprintln!(
+                "Failed to update leaderboard for Codeforces-only member ID {}: {:?}",
+                row.member_id, e
+            );
         }
     }
 
     Ok(())
 }
 
-
-
 pub async fn fetch_and_update_leetcode(
     pool: Arc<PgPool>,
     member_id: i32,

src/graphql/mutations/leetcode_status.rs

@@ -1,7 +1,7 @@
+use super::leaderboard_api::fetch_and_update_leetcode;
 use async_graphql::{Context, Object, Result};
 use sqlx::PgPool;
 use std::sync::Arc;
-use super::leaderboard_api::fetch_and_update_leetcode;
 
 #[derive(Default)]
 pub struct FetchLeetCode;

src/graphql/mutations/mod.rs

@@ -1,23 +1,21 @@
 pub mod attendance_mutations;
+pub mod codeforces_status;
+pub mod leaderboard_api;
+pub mod leetcode_status;
 pub mod member_mutations;
 pub mod project_mutations;
 pub mod streak_mutations;
-pub mod update_leaderboard;  //leaderboard
-pub mod leetcode_status;
-pub mod codeforces_status;
-pub mod leaderboard_api;
-
+pub mod update_leaderboard; //leaderboard
 
 pub use attendance_mutations::AttendanceMutations;
-pub use member_mutations::MemberMutations;
-pub use project_mutations::ProjectMutations;
-pub use streak_mutations::StreakMutations;
-pub use leetcode_status::FetchLeetCode;
 pub use codeforces_status::FetchCodeForces;
-pub use update_leaderboard::LeaderboardMutation;
 pub use leaderboard_api::fetch_and_update_codeforces_stats;
 pub use leaderboard_api::fetch_and_update_leetcode;
 pub use leaderboard_api::update_leaderboard_scores;
+pub use leetcode_status::FetchLeetCode;
+pub use member_mutations::MemberMutations;
+pub use project_mutations::ProjectMutations;
+pub use streak_mutations::StreakMutations;
+pub use update_leaderboard::LeaderboardMutation;
 
-
-//use any mutations for leaderboard if needed
+//use any mutations for leaderboard if needed

src/graphql/mutations/update_leaderboard.rs

@@ -1,5 +1,5 @@
 use async_graphql::{Context, Object, Result as GqlResult};
-use sqlx::{PgPool};
+use sqlx::PgPool;
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -9,34 +9,41 @@ pub struct LeaderboardMutation;
 #[Object]
 impl LeaderboardMutation {
     pub async fn update_leaderboard(&self, ctx: &Context<'_>) -> GqlResult<bool> {
-        let pool = ctx.data::<Arc<PgPool>>()
+        let pool = ctx
+            .data::<Arc<PgPool>>()
             .map_err(|_| async_graphql::Error::new("Failed to access the database pool"))?;
 
-
         let leetcode_stats = sqlx::query!(
             "SELECT member_id, problems_solved, easy_solved, medium_solved, hard_solved, 
                     contests_participated, best_rank
              FROM leetcode_stats"
         )
         .fetch_all(pool.as_ref())
         .await
-        .map_err(|e| async_graphql::Error::new(format!("Failed to fetch LeetCode stats: {:?}", e)))?;
+        .map_err(|e| {
+            async_graphql::Error::new(format!("Failed to fetch LeetCode stats: {:?}", e))
+        })?;
 
-    
         let codeforces_stats = sqlx::query!(
             "SELECT member_id, codeforces_rating, max_rating, contests_participated
              FROM codeforces_stats"
         )
         .fetch_all(pool.as_ref())
         .await
-        .map_err(|e| async_graphql::Error::new(format!("Failed to fetch Codeforces stats: {:?}", e)))?;
+        .map_err(|e| {
+            async_graphql::Error::new(format!("Failed to fetch Codeforces stats: {:?}", e))
+        })?;
 
         let cf_lookup: HashMap<i32, (i32, i32, i32)> = codeforces_stats
             .iter()
             .map(|row| {
                 (
                     row.member_id,
-                    (row.codeforces_rating, row.max_rating, row.contests_participated),
+                    (
+                        row.codeforces_rating,
+                        row.max_rating,
+                        row.contests_participated,
+                    ),
                 )
             })
             .collect();
@@ -48,7 +55,8 @@ impl LeaderboardMutation {
                 + (2 * row.contests_participated)
                 + (100 - row.best_rank / 10).max(0);
 
-            let (codeforces_score, unified_score) = cf_lookup.get(&row.member_id)
+            let (codeforces_score, unified_score) = cf_lookup
+                .get(&row.member_id)
                 .map(|(rating, max_rating, contests)| {
                     let cf_score = (rating / 10) + (max_rating / 20) + (5 * contests);
                     (cf_score, leetcode_score + cf_score)
@@ -72,12 +80,18 @@ impl LeaderboardMutation {
             .await;
 
             if let Err(e) = result {
-                eprintln!("Failed to update leaderboard for member ID {}: {:?}", row.member_id, e);
+                eprintln!(
+                    "Failed to update leaderboard for member ID {}: {:?}",
+                    row.member_id, e
+                );
             }
         }
 
         for row in &codeforces_stats {
-            if leetcode_stats.iter().any(|lc| lc.member_id == row.member_id) {
+            if leetcode_stats
+                .iter()
+                .any(|lc| lc.member_id == row.member_id)
+            {
                 continue;
             }
 
@@ -96,15 +110,17 @@ impl LeaderboardMutation {
                      unified_score = EXCLUDED.unified_score,
                      last_updated = NOW()",
                 row.member_id,
-                0,  
                 codeforces_score,
                 unified_score
             )
             .execute(pool.as_ref())
             .await;
 
             if let Err(e) = result {
-                eprintln!("Failed to update leaderboard for Codeforces-only member ID {}: {:?}", row.member_id, e);
+                eprintln!(
+                    "Failed to update leaderboard for Codeforces-only member ID {}: {:?}",
+                    row.member_id, e
+                );
             }
         }
 

src/graphql/queries/leaderboard_queries.rs

@@ -2,10 +2,12 @@ use async_graphql::{Context, Object};
 use sqlx::PgPool;
 use std::sync::Arc;
 
-use crate::models::leaderboard::{CodeforcesStatsWithName, LeaderboardWithMember, LeetCodeStatsWithName};
+use crate::models::leaderboard::{
+    CodeforcesStatsWithName, LeaderboardWithMember, LeetCodeStatsWithName,
+};
 
 #[derive(Default)]
-pub struct  LeaderboardQueries;
+pub struct LeaderboardQueries;
 
 #[Object]
 impl LeaderboardQueries {

src/graphql/queries/mod.rs

@@ -1,12 +1,11 @@
 pub mod attendance_queries;
+pub mod leaderboard_queries;
 pub mod member_queries;
 pub mod project_queries;
 pub mod streak_queries;
-pub mod leaderboard_queries;
-
 
 pub use attendance_queries::AttendanceQueries;
+pub use leaderboard_queries::LeaderboardQueries;
 pub use member_queries::MemberQueries;
 pub use project_queries::ProjectQueries;
 pub use streak_queries::StreakQueries;
-pub use leaderboard_queries::LeaderboardQueries; 

src/models/leaderboard.rs

@@ -68,4 +68,4 @@ pub struct CodeforcesStatsWithName {
     pub codeforces_rating: i32,
     pub max_rating: i32,
     pub contests_participated: i32,
-}
+}