rs format

Author: JayAgra

src/analyze.rs

@@ -41,21 +41,9 @@ fn season_2023(data: &web::Json<db_main::MainInsert>) -> Result<AnalysisResults,
     let analyzer = vader_sentiment::SentimentIntensityAnalyzer::new();
     let game_data = data.game.split(",").collect::<Vec<_>>();
     let analysis_results: Vec<f64> = vec![
-        analyzer
-            .polarity_scores(data.defend.as_str())
-            .get("compound")
-            .unwrap()
-            .clone(),
-        analyzer
-            .polarity_scores(data.driving.as_str())
-            .get("compound")
-            .unwrap()
-            .clone(),
-        analyzer
-            .polarity_scores(data.overall.as_str())
-            .get("compound")
-            .unwrap()
-            .clone(),
+        analyzer.polarity_scores(data.defend.as_str()).get("compound").unwrap().clone(),
+        analyzer.polarity_scores(data.driving.as_str()).get("compound").unwrap().clone(),
+        analyzer.polarity_scores(data.overall.as_str()).get("compound").unwrap().clone(),
     ];
 
     let mut score: f64 = 0.0;
@@ -208,10 +196,7 @@ fn season_2023(data: &web::Json<db_main::MainInsert>) -> Result<AnalysisResults,
 
     let string_mps_scores: Vec<String> = mps_scores.iter().map(|float| float.to_string()).collect();
 
-    let string_analysis_results: Vec<String> = analysis_results
-        .iter()
-        .map(|float| float.to_string())
-        .collect();
+    let string_analysis_results: Vec<String> = analysis_results.iter().map(|float| float.to_string()).collect();
 
     Ok(AnalysisResults {
         weight: string_mps_scores.join(","),
@@ -229,25 +214,12 @@ pub struct MatchTime2024 {
 
 fn season_2024(data: &web::Json<db_main::MainInsert>) -> Result<AnalysisResults, Error> {
     let analyzer = vader_sentiment::SentimentIntensityAnalyzer::new();
-    let game_data: Vec<MatchTime2024> =
-        serde_json::from_str(data.game.as_str()).expect("failed to convert");
+    let game_data: Vec<MatchTime2024> = serde_json::from_str(data.game.as_str()).expect("failed to convert");
 
     let analysis_results: Vec<f64> = vec![
-        analyzer
-            .polarity_scores(data.defend.as_str())
-            .get("compound")
-            .unwrap()
-            .clone(),
-        analyzer
-            .polarity_scores(data.driving.as_str())
-            .get("compound")
-            .unwrap()
-            .clone(),
-        analyzer
-            .polarity_scores(data.overall.as_str())
-            .get("compound")
-            .unwrap()
-            .clone(),
+        analyzer.polarity_scores(data.defend.as_str()).get("compound").unwrap().clone(),
+        analyzer.polarity_scores(data.driving.as_str()).get("compound").unwrap().clone(),
+        analyzer.polarity_scores(data.overall.as_str()).get("compound").unwrap().clone(),
     ];
 
     let mut score: f64 = 0.0;
@@ -294,9 +266,11 @@ fn season_2024(data: &web::Json<db_main::MainInsert>) -> Result<AnalysisResults,
             8 => auto_scores = time.intake as i64,
             _ => {}
         }
-        intake_time += time.intake;
-        travel_time += time.travel;
-        outtake_time += time.outtake;
+        if time.score_type == 0 || time.score_type == 1 || time.score_type == 9 {
+            intake_time += time.intake;
+            travel_time += time.travel;
+            outtake_time += time.outtake;
+        }
     }
 
     score += auto_scores as f64 * 18.0;
@@ -316,8 +290,7 @@ fn season_2024(data: &web::Json<db_main::MainInsert>) -> Result<AnalysisResults,
         fast_intake = score * (100.0 / (intake_time / (game_data.len() - 3) as f64));
         fast_travel = score * (100.0 / (travel_time / (game_data.len() - 3) as f64));
         fast_shoot = score * (100.0 / (outtake_time / (game_data.len() - 3) as f64));
-        fast_cycle = score
-            * (100.0 / (intake_time + travel_time + outtake_time / (game_data.len() - 3) as f64));
+        fast_cycle = score * (100.0 / (intake_time + travel_time + outtake_time / (game_data.len() - 3) as f64));
     } else {
         fast_intake = 0.0;
         fast_travel = 0.0;
@@ -345,8 +318,7 @@ fn season_2024(data: &web::Json<db_main::MainInsert>) -> Result<AnalysisResults,
 
     let string_mps_scores: Vec<String> = mps_scores.iter().map(|float| float.to_string()).collect();
 
-    let string_analysis_results: Vec<String> =
-        analysis.iter().map(|float| float.to_string()).collect();
+    let string_analysis_results: Vec<String> = analysis.iter().map(|float| float.to_string()).collect();
 
     Ok(AnalysisResults {
         weight: string_mps_scores.join(","),

src/auth.rs

@@ -27,26 +27,19 @@ pub struct CreateForm {
     password: String,
 }
 
-pub async fn create_account(
-    pool: &db_auth::Pool,
-    create_form: web::Json<CreateForm>,
-) -> impl Responder {
+pub async fn create_account(pool: &db_auth::Pool, create_form: web::Json<CreateForm>) -> impl Responder {
     // check password length is between 8 and 32, inclusive
     if create_form.password.len() >= 8 && create_form.password.len() <= 64 {
         // check if user is a sketchy motherfucker
         let regex = Regex::new(r"^[a-z0-9A-Z- ~!@#$%^&*()=+/\_[_]{}|?.,]{3,64}$").unwrap();
-        if !regex.is_match(&create_form.username)
-            || !regex.is_match(&create_form.password)
-            || !regex.is_match(&create_form.full_name)
-        {
+        if !regex.is_match(&create_form.username) || !regex.is_match(&create_form.password) || !regex.is_match(&create_form.full_name) {
             return HttpResponse::BadRequest()
                 .status(StatusCode::from_u16(400).unwrap())
                 .insert_header(("Cache-Control", "no-cache"))
                 .body("{\"status\": \"you_sketchy_motherfucker\"}");
         }
         // check if username is taken
-        let target_user_temp: Result<db_auth::User, actix_web::Error> =
-            db_auth::get_user_username(pool, create_form.username.clone()).await;
+        let target_user_temp: Result<db_auth::User, actix_web::Error> = db_auth::get_user_username(pool, create_form.username.clone()).await;
         if target_user_temp.is_ok() {
             return HttpResponse::BadRequest()
                 .status(StatusCode::from_u16(409).unwrap())
@@ -57,12 +50,7 @@ pub async fn create_account(
             // check access key validity
             if create_form.access != "00000" {
                 let access_key_temp: Result<Vec<db_auth::AccessKey>, actix_web::Error> =
-                    db_auth::get_access_key(
-                        pool,
-                        create_form.access.clone(),
-                        db_auth::AccessKeyQuery::ById,
-                    )
-                    .await;
+                    db_auth::get_access_key(pool, create_form.access.clone(), db_auth::AccessKeyQuery::ById).await;
                 if access_key_temp.is_err() {
                     return HttpResponse::BadRequest()
                         .status(StatusCode::from_u16(403).unwrap())
@@ -72,15 +60,14 @@ pub async fn create_account(
                     // insert into database
                     let access_key = access_key_temp.unwrap().first().cloned();
                     if let Some(valid_key) = access_key {
-                        let user_temp: Result<db_auth::User, actix_web::Error> =
-                            db_auth::create_user(
-                                pool,
-                                valid_key.team,
-                                html_escape::encode_text(&create_form.full_name).to_string(),
-                                html_escape::encode_text(&create_form.username).to_string(),
-                                html_escape::encode_text(&create_form.password).to_string(),
-                            )
-                            .await;
+                        let user_temp: Result<db_auth::User, actix_web::Error> = db_auth::create_user(
+                            pool,
+                            valid_key.team,
+                            html_escape::encode_text(&create_form.full_name).to_string(),
+                            html_escape::encode_text(&create_form.username).to_string(),
+                            html_escape::encode_text(&create_form.password).to_string(),
+                        )
+                        .await;
                         // send final success/failure for creation
                         if user_temp.is_err() {
                             return HttpResponse::BadRequest()
@@ -139,8 +126,7 @@ pub async fn login(
     login_form: web::Json<LoginForm>,
 ) -> impl Responder {
     // try to get target user from database
-    let target_user_temp: Result<db_auth::User, actix_web::Error> =
-        db_auth::get_user_username(pool, login_form.username.clone()).await;
+    let target_user_temp: Result<db_auth::User, actix_web::Error> = db_auth::get_user_username(pool, login_form.username.clone()).await;
     if target_user_temp.is_err() {
         // query error, send failure response
         return HttpResponse::BadRequest()
@@ -171,10 +157,11 @@ pub async fn login(
             // save the username to the identity
             identity.remember(login_form.username.clone());
             // write the user object to the session
-            session.write().unwrap().user_map.insert(
-                target_user.clone().username.to_string(),
-                target_user.clone(),
-            );
+            session
+                .write()
+                .unwrap()
+                .user_map
+                .insert(target_user.clone().username.to_string(), target_user.clone());
             // if admin, send admin success response
             if target_user.admin == "true" {
                 // user is admin, send admin response for client cookie
@@ -214,12 +201,8 @@ pub async fn login(
     }
 }
 
-pub async fn delete_account(
-    pool: &db_auth::Pool,
-    login_form: web::Json<LoginForm>,
-) -> Result<HttpResponse, actix_web::Error> {
-    let target_user_temp: Result<db_auth::User, actix_web::Error> =
-        db_auth::get_user_username(pool, login_form.username.clone()).await;
+pub async fn delete_account(pool: &db_auth::Pool, login_form: web::Json<LoginForm>) -> Result<HttpResponse, actix_web::Error> {
+    let target_user_temp: Result<db_auth::User, actix_web::Error> = db_auth::get_user_username(pool, login_form.username.clone()).await;
     if target_user_temp.is_err() {
         return Ok(HttpResponse::BadRequest()
             .status(StatusCode::from_u16(400).unwrap())
@@ -240,12 +223,7 @@ pub async fn delete_account(
             .is_ok()
         {
             Ok(HttpResponse::Ok().json(
-                db_auth::execute_manage_user(
-                    &pool,
-                    db_auth::UserManageAction::DeleteUser,
-                    [target_user.id.to_string(), "".to_string()],
-                )
-                .await?,
+                db_auth::execute_manage_user(&pool, db_auth::UserManageAction::DeleteUser, [target_user.id.to_string(), "".to_string()]).await?,
             ))
         } else {
             Ok(HttpResponse::BadRequest()
@@ -261,10 +239,7 @@ pub async fn delete_account(
     }
 }
 
-pub async fn logout(
-    session: web::Data<RwLock<crate::Sessions>>,
-    identity: Identity,
-) -> HttpResponse {
+pub async fn logout(session: web::Data<RwLock<crate::Sessions>>, identity: Identity) -> HttpResponse {
     // if session exists, proceed
     if let Some(id) = identity.identity() {
         // forget identity