send notifiation to user + vorstand if user completes 'äquatorpreis' or 'fahrtenabzeichen'; Fixes #746

src/model/personal/equatorprice.rs

@@ -1,3 +1,4 @@
+use crate::model::{logbook::Logbook, stat::Stat, user::User};
 use serde::Serialize;
 
 #[derive(Serialize, PartialEq, Debug)]
@@ -85,3 +86,19 @@ impl Next {
         }
     }
 }
+
+pub(crate) async fn new_level_with_last_log(
+    db: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    user: &User,
+) -> Option<String> {
+    let rowed_km = Stat::total_km_tx(db, user).await.rowed_km;
+
+    if let Some(last_logbookentry) = Logbook::completed_with_user_tx(db, user).await.last() {
+        let last_trip_km = last_logbookentry.logbook.distance_in_km.unwrap();
+        if Level::curr_level(rowed_km) != Level::curr_level(rowed_km - last_trip_km as i32) {
+            return Some(Level::curr_level(rowed_km).desc().to_string());
+        }
+    }
+
+    None
+}

src/model/personal/rowingbadge.rs

@@ -2,7 +2,7 @@ use std::cmp;
 
 use chrono::{Datelike, Local, NaiveDate};
 use serde::Serialize;
-use sqlx::SqlitePool;
+use sqlx::{Sqlite, SqlitePool, Transaction};
 
 use crate::model::{
     logbook::{Filter, Logbook, LogbookWithBoatAndRowers},
@@ -111,11 +111,44 @@ pub(crate) struct Status {
 }
 
 impl Status {
-    pub(crate) async fn for_user(db: &SqlitePool, user: &User) -> Option<Self> {
+    fn calc(
+        agebracket: &AgeBracket,
+        rowed_km: i32,
+        single_day_trips_over_required_distance: usize,
+        multi_day_trips_over_required_distance: usize,
+        year: i32,
+    ) -> Self {
+        let category = agebracket.cat().to_string();
+
+        let required_km = agebracket.dist_in_km();
+        let missing_km = cmp::max(required_km - rowed_km, 0);
+
+        let achieved = missing_km == 0
+            && (multi_day_trips_over_required_distance >= 1
+                || single_day_trips_over_required_distance >= 2);
+
+        Self {
+            year,
+            rowed_km,
+            category,
+            required_km,
+            missing_km,
+            multi_day_trips_over_required_distance: vec![],
+            single_day_trips_over_required_distance: vec![],
+            multi_day_trips_required_distance: agebracket.required_dist_multi_day_in_km(),
+            single_day_trips_required_distance: agebracket.required_dist_single_day_in_km(),
+            achieved,
+        }
+    }
+
+    pub(crate) async fn for_user_tx(
+        db: &mut Transaction<'_, Sqlite>,
+        user: &User,
+        exclude_last_log: bool,
+    ) -> Option<Self> {
         let Ok(agebracket) = AgeBracket::try_from(user) else {
             return None;
         };
-        let category = agebracket.cat().to_string();
 
         let year = if Local::now().month() == 1 {
             Local::now().year() - 1
@@ -123,44 +156,66 @@ impl Status {
             Local::now().year()
         };
 
-        let rowed_km = Stat::person(db, Some(year), user).await.rowed_km;
-        let required_km = agebracket.dist_in_km();
-        let missing_km = cmp::max(required_km - rowed_km, 0);
-
+        let rowed_km = Stat::person_tx(db, Some(year), user).await.rowed_km;
         let single_day_trips_over_required_distance =
-            Logbook::completed_wanderfahrten_with_user_over_km_in_year(
+            Logbook::completed_wanderfahrten_with_user_over_km_in_year_tx(
                 db,
                 user,
                 agebracket.required_dist_single_day_in_km(),
                 year,
                 Filter::SingleDayOnly,
+                exclude_last_log,
             )
             .await;
         let multi_day_trips_over_required_distance =
-            Logbook::completed_wanderfahrten_with_user_over_km_in_year(
+            Logbook::completed_wanderfahrten_with_user_over_km_in_year_tx(
                 db,
                 user,
                 agebracket.required_dist_multi_day_in_km(),
                 year,
-                Filter::MultiDazOnly,
+                Filter::MultiDayOnly,
+                exclude_last_log,
             )
             .await;
 
-        let achieved = missing_km == 0
-            && (multi_day_trips_over_required_distance.len() >= 1
-                || single_day_trips_over_required_distance.len() >= 2);
+        let ret = Self::calc(
+            &agebracket,
+            rowed_km,
+            single_day_trips_over_required_distance.len(),
+            multi_day_trips_over_required_distance.len(),
+            year,
+        );
 
         Some(Self {
-            year,
-            rowed_km,
-            category,
-            required_km,
-            missing_km,
             multi_day_trips_over_required_distance,
             single_day_trips_over_required_distance,
-            multi_day_trips_required_distance: agebracket.required_dist_multi_day_in_km(),
-            single_day_trips_required_distance: agebracket.required_dist_single_day_in_km(),
-            achieved,
+            ..ret
         })
     }
+
+    pub(crate) async fn for_user(db: &SqlitePool, user: &User) -> Option<Self> {
+        let mut tx = db.begin().await.unwrap();
+        let ret = Self::for_user_tx(&mut tx, user, false).await;
+        tx.commit().await.unwrap();
+        ret
+    }
+
+    pub(crate) async fn completed_with_last_log(
+        db: &mut Transaction<'_, Sqlite>,
+        user: &User,
+    ) -> bool {
+        if let Some(status) = Self::for_user_tx(db, user, false).await {
+            // if user has agebracket...
+            if status.achieved {
+                // ... and has achieved the 'Fahrtenabzeichen'
+                let without_last_entry = Self::for_user_tx(db, user, true).await.unwrap();
+                if !without_last_entry.achieved {
+                    // ... and this wasn't the case before the last logentry
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
 }